Changeset 54cb48f in rtems


Ignore:
Timestamp:
May 12, 2005, 6:25:29 PM (16 years ago)
Author:
Jennifer Averett <Jennifer.Averett@…>
Branches:
4.10, 4.11, 4.8, 4.9, 5, master
Children:
f583bb2
Parents:
f321fdc8
Message:

2005-05-12 Jennifer Averett <jennifer.averett@…>

  • README.VME, include/bsp.h, irq/irq.h, network/GT64260eth.c, pci/detect_host_bridge.c, pci/gtpcireg.h, pci/pci.c, pci/pci.h, pci/pci_interface.c, pci/pcifinddevice.c: Submitted by Kate Feng <feng1@…> as RTEMS-MVME5500 BSP v1.1 release. Modifications made to merge this release with the current tree.
Location:
c/src/lib/libbsp/powerpc/mvme5500
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • c/src/lib/libbsp/powerpc/mvme5500/ChangeLog

    rf321fdc8 r54cb48f  
     12005-05-12      Jennifer Averett <jennifer.averett@oarcorp.com>
     2
     3        * README.VME, include/bsp.h, irq/irq.h, network/GT64260eth.c,
     4        pci/detect_host_bridge.c, pci/gtpcireg.h, pci/pci.c, pci/pci.h,
     5        pci/pci_interface.c, pci/pcifinddevice.c:
     6        Submitted by Kate Feng <feng1@bnl.gov> as RTEMS-MVME5500 BSP v1.1 release.
     7        Modifications made to merge this release with the current tree.
     8
    192005-05-10      Jennifer Averett <jennifer.averett@oarcorp.com>
    210
  • c/src/lib/libbsp/powerpc/mvme5500/README.VME

    rf321fdc8 r54cb48f  
    77synchronize between the CPU and PCI activities. The PCI sync is
    88implemented in pci/pci_interface.c. For more example of the usage,one
    9 can refrence the drvOMS58.cc file that is posted in synAppRTEMS of
     9can reference the drvOMS58.cc file that is posted in synAppRTEMS of
    1010http://www.nsls.bnl.gov/organization/UserScience/Detectors/Software/Default.htm.
    1111
  • c/src/lib/libbsp/powerpc/mvme5500/include/bsp.h

    rf321fdc8 r54cb48f  
    4343#define PCI1_MEM_BASE           0xe0000000
    4444#define PCI1_MEM_SIZE           0x10000000
     45
     46/* Needed for hot adding via PMCspan on the PCI0 local bus.
     47 * This is board dependent, only because mvme5500
     48 * supports hot adding and has more than one local PCI
     49 * bus.
     50 */
     51#define BSP_MAX_PCI_BUS_ON_PCI0 8
     52#define BSP_MAX_PCI_BUS_ON_PCI1 2
     53#define BSP_MAX_PCI_BUS  (BSP_MAX_PCI_BUS_ON_PCI0+BSP_MAX_PCI_BUS_ON_PCI1)
     54
    4555
    4656/* The glues to Till's vmeUniverse, although the name does not
  • c/src/lib/libbsp/powerpc/mvme5500/irq/irq.h

    rf321fdc8 r54cb48f  
    126126  BSP_ISA_UART_COM1_IRQ         = BSP_GPP_IRQ_LOWEST_OFFSET,
    127127  BSP_GPP8_IRQ_OFFSET           = BSP_GPP_IRQ_LOWEST_OFFSET+8,
     128  BSP_GPP_PMC1_INTA             = BSP_GPP8_IRQ_OFFSET,
    128129  BSP_GPP16_IRQ_OFFSET          = BSP_GPP_IRQ_LOWEST_OFFSET+16,
    129130  BSP_GPP24_IRQ_OFFSET          = BSP_GPP_IRQ_LOWEST_OFFSET+24,
  • c/src/lib/libbsp/powerpc/mvme5500/network/GT64260eth.c

    rf321fdc8 r54cb48f  
    132132static void GTeth_init_rx_ring(struct GTeth_softc *sc);
    133133static void GT64260eth_daemon(void *arg);
    134 static int GT64260eth_sendpacket(struct GTeth_softc *sc,struct mbuf *m,enum GTeth_txprio);
    135 static unsigned GTeth_txq_done(struct GTeth_softc *sc, enum GTeth_txprio txprio);
    136 static void GTeth_tx_cleanup(struct GTeth_softc *sc, enum GTeth_txprio, int);
    137 static void GTeth_tx_start(struct GTeth_softc *sc, enum GTeth_txprio);
    138 static void GTeth_tx_stop(struct GTeth_softc *sc, enum GTeth_whack_op op);
    139 static void GTeth_rx_cleanup(struct GTeth_softc *sc, enum GTeth_rxprio);
    140 static int GT64260eth_rx(struct GTeth_softc *sc, enum GTeth_rxprio);
     134static int GT64260eth_sendpacket(struct GTeth_softc *sc,struct mbuf *m);
     135static unsigned GTeth_txq_done(struct GTeth_softc *sc);
     136static void GTeth_tx_cleanup(struct GTeth_softc *sc);
     137static void GTeth_tx_start(struct GTeth_softc *sc);
     138static void GTeth_tx_stop(struct GTeth_softc *sc);
     139static void GTeth_rx_cleanup(struct GTeth_softc *sc);
     140static int GT64260eth_rx(struct GTeth_softc *sc);
    141141static void GTeth_rx_setup(struct GTeth_softc *sc);
    142 static void GTeth_rxprio_setup(struct GTeth_softc *sc, enum GTeth_rxprio);
    143 static void GTeth_rx_stop(struct GTeth_softc *dc, enum GTeth_whack_op op);
     142static void GTeth_rxprio_setup(struct GTeth_softc *sc);
     143static void GTeth_rx_stop(struct GTeth_softc *dc);
    144144static void GT64260eth_isr();
    145145static int GTeth_hash_compute(struct GTeth_softc *sc,unsigned char eaddr[ETHER_ADDR_LEN]);
     
    151151
    152152static struct GTeth_softc *root_GT64260eth_dev = NULL;
    153 static int GTeth_MissedFrame_err=0; 
    154153
    155154static void GT64260eth_irq_on(const rtems_irq_connect_data *irq)
     
    161160    outl(0x30883444,ETH0_EIMR); /* MOTLoad default interrupt mask */
    162161    return;
    163   }
     162  } 
    164163}
    165164
     
    187186  outl( ~cause,ETH0_EICR);  /* clear the ICR */
    188187
    189   if (cause & (ETH_IR_RxBuffer_3|ETH_IR_RxError_3)) {
     188  /* ETH_IR_RxBuffer_3|ETH_IR_RxError_3 */
     189  if (cause & 0x880000) {
    190190     sc->stats.rxInterrupts++;
    191191     events |= RX_EVENT;
    192192  }
    193193  /* If there is an error, we want to continue to next descriptor */
    194   if (cause & (ETH_IR_TxBufferHigh|ETH_IR_TxEndHigh|ETH_IR_TxErrorHigh)) {
     194  /* ETH_IR_TxBufferHigh|ETH_IR_TxEndHigh|ETH_IR_TxErrorHigh */
     195  if (cause & 0x444) {
    195196       sc->stats.txInterrupts++;
    196197       events |= TX_EVENT;
    197        if ((sc->txq_nactive) && ((inl(ETH0_ESDCMR)&ETH_ESDCMR_TXDH)==0))
    198           outl(ETH_ESDCMR_TXDH | ETH_ESDCMR_ERD,ETH0_ESDCMR);
    199   }
     198       /* It seems to be unnecessary. However, it's there
     199        * to be on the safe side due to the datasheet.
     200        * So far, it does not seem to affect the network performance
     201        * based on the EPICS catime.
     202        */
     203       /* ETH_ESDCMR_TXDH | ETH_ESDCMR_ERD = 0x800080 */
     204       if ((sc->txq_nactive > 1)&& ((inl(ETH0_ESDCMR)&ETH_ESDCMR_TXDH)==0))
     205          outl(0x800080,ETH0_ESDCMR);
     206
     207
     208  }
    200209  if ( (!cause) || (cause & 0x803d00)) {
    201210       sc->intr_errsts[sc->intr_err_ptr2++]=cause;
     
    236245
    237246#ifndef GE_NOTX
    238   GTeth_tx_start(sc, GE_TXPRIO_HI);
     247  GTeth_tx_start(sc);
    239248#endif
    240249
     
    287296  sc->arpcom.ac_if.if_flags &= ~IFF_RUNNING;
    288297#ifndef GE_NOTX
    289   GTeth_tx_stop(sc, GE_WHACK_STOP);
     298  GTeth_tx_stop(sc);
    290299#endif
    291300#ifndef GE_NORX
    292   GTeth_rx_stop(sc, GE_WHACK_STOP);
     301  GTeth_rx_stop(sc);
    293302#endif
    294303  sc->sc_hashtable = NULL;
     
    524533  printf("     Receive Packets:%-8lu\n", ifp->if_ipackets);
    525534  printf("     Receive  errors:%-8lu\n", ifp->if_ierrors);
    526   printf(" Missed Frame errors:%-8u\n",  GTeth_MissedFrame_err);
    527535  printf("      Framing Errors:%-8lu\n", sc->stats.frame_errors);
    528536  printf("          Crc Errors:%-8lu\n", sc->stats.crc_errors);
     
    535543  printf("    Tx/Rx collisions:%-8lu\n", ifp->if_collisions);
    536544  printf("         Active Txqs:%-8u\n", sc->txq_nactive);
    537 }
    538 
    539 void GT64260eth_err()
    540 {
    541   printf(" Missed Frame errors:%-8u\n", GTeth_MissedFrame_err);
    542545}
    543546
     
    678681}
    679682
    680 static void GTeth_rxprio_setup(struct GTeth_softc *sc, enum GTeth_rxprio rxprio)
    681 {
    682 
    683   if (GTeth_debug>0) printk("GTeth_rxprio_setup(\n");
     683void GTeth_rxprio_setup(struct GTeth_softc *sc)
     684{
     685
    684686  GTeth_init_rx_ring(sc);
    685687
    686   sc->rxq_intrbits = ETH_IR_RxBuffer | ETH_IR_RxError;
    687 
    688   switch (rxprio) {
    689     case GE_RXPRIO_HI:
    690       sc->rxq_intrbits |= ETH_IR_RxBuffer_3|ETH_IR_RxError_3;
    691          break;
    692     case GE_RXPRIO_MEDHI:
    693          sc->rxq_intrbits |= ETH_IR_RxBuffer_2|ETH_IR_RxError_2;
    694          break;
    695     case GE_RXPRIO_MEDLO:
    696          sc->rxq_intrbits |= ETH_IR_RxBuffer_1|ETH_IR_RxError_1;
    697          break;
    698     case GE_RXPRIO_LO:
    699          sc->rxq_intrbits |= ETH_IR_RxBuffer_0|ETH_IR_RxError_0;
    700          break;
    701   }
    702   if (GTeth_debug>0) printk(")");
    703 }
    704 
    705 static int GT64260eth_rx(struct GTeth_softc *sc, enum GTeth_rxprio rxprio)
     688  sc->rxq_intrbits = ETH_IR_RxBuffer|ETH_IR_RxError|ETH_IR_RxBuffer_3|ETH_IR_RxError_3;
     689}
     690
     691static int GT64260eth_rx(struct GTeth_softc *sc)
    706692{
    707693  struct ifnet *ifp = &sc->arpcom.ac_if;
     
    709695  int nloops=0;
    710696
     697#ifdef GT_DEBUG
    711698  if (GTeth_rx_debug>0) printk("GT64260eth_rx(");
    712   if (GTeth_rx_debug>5) printk("(%d)", rxprio);
     699#endif
    713700
    714701  while (sc->rxq_active > 0) {
     
    750737     */
    751738
    752     if (GTeth_rx_debug>0) printk("desc%d: cmdsts=%x, len=%d\n",
    753            sc->rxq_fi,cmdsts,byteCount);
    754739    nloops++;
    755740    /*
     
    759744     */
    760745    if ((cmdsts & (RX_CMD_F|RX_CMD_L|RX_STS_ES)) !=
    761                             (RX_CMD_F|RX_CMD_L) ||
    762                     byteCount > sc->sc_max_frame_length) {
    763         if (GTeth_rx_debug>0) printk("Rx Error");
    764         --sc->rxq_active;
    765         ifp->if_ipackets++;
    766         ifp->if_ierrors++;
     746                            (RX_CMD_F|RX_CMD_L) ||
     747                    byteCount > sc->sc_max_frame_length) {
     748        --sc->rxq_active;
     749        ifp->if_ipackets++;
     750        ifp->if_ierrors++;
    767751        if (cmdsts & RX_STS_OR) sc->stats.or_errors++;
    768752        if (cmdsts & RX_STS_CE) sc->stats.crc_errors++;
    769         if (cmdsts & RX_STS_MFL) sc->stats.length_errors++;
    770         if (cmdsts & RX_STS_SF) sc->stats.frame_errors++;
    771         /*      if (cmdsts & RX_STS_M) GTeth_MissedFrame_err++;*/
     753        if (cmdsts & RX_STS_MFL) sc->stats.length_errors++;
     754        if (cmdsts & RX_STS_SF) sc->stats.frame_errors++;
    772755        if ((cmdsts & RX_STS_LC) || (cmdsts & RX_STS_COL))
    773            ifp->if_collisions++;
    774         goto give_it_back;
     756           ifp->if_collisions++;
     757        goto give_it_back;
    775758     }
    776 
    777759     m = sc->rxq_mbuf[sc->rxq_fi];
    778      sc->rxq_mbuf[sc->rxq_fi] = NULL;
    779760     m->m_len = m->m_pkthdr.len = byteCount - sizeof(struct ether_header);
    780761     eh = mtod (m, struct ether_header *);
    781762     m->m_data += sizeof(struct ether_header);
    782763     ether_input (ifp, eh, m);
    783      if (GTeth_rx_debug>20) {
    784        if ( m->m_flags & M_BCAST ) printk("desc%d broadcast\n",sc->rxq_fi);
    785        if ( m->m_flags & M_MCAST ) printk("multicast ");
    786      }
    787764
    788765     ifp->if_ipackets++;
     
    804781     sc->rxq_active++;
    805782  } /* while (sc->rxq_active > 0) */
     783#ifdef GT_DEBUG
    806784  if (GTeth_rx_debug>0) printk(")");
     785#endif
    807786  return nloops;
    808787}
     
    813792  if (GTeth_rx_debug>0) printk("GTeth_rx_setup(");
    814793
    815   GTeth_rxprio_setup(sc, GE_RXPRIO_HI);
     794  GTeth_rxprio_setup(sc);
    816795
    817796  if ((sc->sc_flags & GE_RXACTIVE) == 0) {
     
    830809}
    831810
    832 static void GTeth_rx_cleanup(struct GTeth_softc *sc, enum GTeth_rxprio rxprio)
     811static void GTeth_rx_cleanup(struct GTeth_softc *sc)
    833812{
    834813  int i;
    835814
    836815  if (GTeth_rx_debug>0) printk( "GTeth_rx_cleanup(");
    837   if (sc->rxq_curpkt)
    838      m_freem(sc->rxq_curpkt);
    839816
    840817  for (i=0; i< RX_RING_SIZE; i++) {
     
    847824}
    848825
    849 static void GTeth_rx_stop(struct GTeth_softc *sc, enum GTeth_whack_op op)
     826static void GTeth_rx_stop(struct GTeth_softc *sc)
    850827{
    851828  if (GTeth_rx_debug>0) printk( "GTeth_rx_stop(");
     
    858835     rtems_bsp_delay(10);
    859836  } while (inl(ETH0_ESDCMR) & ETH_ESDCMR_AR);
    860   GTeth_rx_cleanup(sc, GE_RXPRIO_HI);
     837  GTeth_rx_cleanup(sc);
    861838  if (GTeth_rx_debug>0) printk(")");
    862839}
     
    930907}
    931908
    932 static int GT64260eth_sendpacket(struct GTeth_softc *sc,struct mbuf *m, enum GTeth_txprio txprio)
     909static int GT64260eth_sendpacket(struct GTeth_softc *sc,struct mbuf *m)
    933910{
    934911  volatile struct GTeth_desc *txd = &sc->txq_desc[sc->txq_lo];
    935912  unsigned intrmask = sc->sc_intrmask;
    936913  unsigned index= sc->txq_lo;
    937 
    938   if (GTeth_debug>0) printk("sendpacket(");
    939914
    940915  /*
     
    988963  txd->ed_bufptr = (unsigned) mtod(m, void*);
    989964  txd->ed_lencnt = m->m_len << 16;
    990   txd->ed_cmdsts = TX_CMD_L|TX_CMD_GC|TX_CMD_P|TX_CMD_O|TX_CMD_F|TX_CMD_EI;
     965  /*txd->ed_cmdsts = TX_CMD_L|TX_CMD_GC|TX_CMD_P|TX_CMD_O|TX_CMD_F|TX_CMD_EI;*/
     966  txd->ed_cmdsts = 0x80c70000;
    991967
    992968#ifdef GT_DEBUG
     
    996972  /*
    997973   * Tell the SDMA engine to "Fetch!"
    998    * Start Tx high and Tx low.
    999    */
    1000   outl(ETH_ESDCMR_TXDH,ETH0_ESDCMR);
     974   * Start Tx high.
     975   */
    1001976  sc->txq_nactive++;
     977  outl(0x800080, ETH0_ESDCMR); /* ETH_ESDCMR_TXDH| ETH_ESDCMR_ERD */
    1002978  if ( ++sc->txq_lo == TX_RING_SIZE) sc->txq_lo = 0;
    1003979  sc->txq_free--;
    1004980
     981#if 0
    1005982  /*
    1006983   * Since we have put an item into the packet queue, we now want
     
    1013990      outl(sc->sc_intrmask, ETH0_EIMR);
    1014991  }
     992#endif
    1015993
    1016994#if 0
     
    1021999#endif
    10221000
    1023   if (GTeth_debug>0) printk(")");
    10241001  return 1;
    10251002}
    10261003
    1027 static unsigned GTeth_txq_done(struct GTeth_softc *sc, enum GTeth_txprio txprio)
     1004static unsigned GTeth_txq_done(struct GTeth_softc *sc)
    10281005{
    10291006  if (GTeth_debug>0) printk("Txdone(" );
     
    10721049}
    10731050
    1074 static void GTeth_tx_start(struct GTeth_softc *sc, enum GTeth_txprio txprio)
     1051static void GTeth_tx_start(struct GTeth_softc *sc)
    10751052{
    10761053  int i;
     
    11181095#endif
    11191096  }
    1120 
    1121   switch (txprio) {
    1122     case GE_TXPRIO_HI:
    1123       sc->txq_intrbits = ETH_IR_TxEndHigh|ETH_IR_TxBufferHigh;
    1124          sc->txq_esdcmrbits = ETH_ESDCMR_TXDH; /* Start Tx high */
    1125          sc->txq_epsrbits = ETH_EPSR_TxHigh;
    1126          /* offset to current tx desc ptr reg */
    1127          sc->txq_ectdp = (caddr_t)ETH0_ECTDP1;
    1128          /* Current Tx Desc Pointer 1 */
    1129          outl(sc->txq_desc_busaddr,ETH0_ECTDP1);
    1130 #ifdef GT_DEBUG
    1131          printk("ETH0_ECTDP1 %x",inl(ETH0_ECTDP1));
    1132 #endif
    1133          break;
    1134 
    1135     case GE_TXPRIO_LO:
    1136          sc->txq_intrbits = ETH_IR_TxEndLow|ETH_IR_TxBufferLow;
    1137          sc->txq_esdcmrbits = ETH_ESDCMR_TXDL; /* Start TX low */
    1138          sc->txq_epsrbits = ETH_EPSR_TxLow;
    1139          sc->txq_ectdp = (caddr_t)ETH0_ECTDP0;
    1140          /* Current Tx Desc Pointer 0 */
    1141          outl(sc->txq_desc_busaddr,ETH0_ECTDP0);
    1142 #ifdef GT_DEBUG
    1143          printk("ETH0_ECTDP1 %x",inl(ETH0_ECTDP0));
    1144 #endif
    1145          break;
    1146 
    1147     default:
    1148          printk("Invalid Txq prio\n");
    1149          break;
    1150   }
    11511097 
     1098  sc->txq_intrbits = ETH_IR_TxEndHigh|ETH_IR_TxBufferHigh;
     1099  sc->txq_esdcmrbits = ETH_ESDCMR_TXDH; /* Start Tx high */
     1100  sc->txq_epsrbits = ETH_EPSR_TxHigh;
     1101  /* offset to current tx desc ptr reg */
     1102  sc->txq_ectdp = (caddr_t)ETH0_ECTDP1;
     1103  /* Current Tx Desc Pointer 1 */
     1104  outl(sc->txq_desc_busaddr,ETH0_ECTDP1);
     1105
    11521106#ifdef GT_DEBUG
    11531107  printk(")\n");
     
    11551109}
    11561110
    1157 static void GTeth_tx_cleanup(struct GTeth_softc *sc,enum GTeth_txprio txprio,int flush)
     1111static void GTeth_tx_cleanup(struct GTeth_softc *sc)
    11581112{
    11591113  int i;
    11601114
    1161   if (GTeth_debug>0) printk( "GTeth_tx_cleanup(");
    1162 
    1163   if (!flush) {
    1164      if (GTeth_debug>0) printk("--");
    1165      return;
    1166   }
    11671115  for (i=0; i< TX_RING_SIZE; i++) {
    11681116    if (sc->txq_mbuf[i]) {
     
    11711119    }
    11721120  }
    1173   if (GTeth_debug>0) printk(")");
    1174 }
    1175 
    1176 static void GTeth_tx_stop(struct GTeth_softc *sc, enum GTeth_whack_op op)
    1177 {
    1178   if (GTeth_debug>0) printk("GTeth_tx_stop( ");
    1179 
     1121}
     1122
     1123static void GTeth_tx_stop(struct GTeth_softc *sc)
     1124{
    11801125  /* SDMA command register : stop Tx high and low */
    11811126  outl(ETH_ESDCMR_STDH|ETH_ESDCMR_STDL, ETH0_ESDCMR);
    11821127
    1183   GTeth_txq_done(sc, GE_TXPRIO_HI);
     1128  GTeth_txq_done(sc);
    11841129  sc->sc_intrmask &= ~(ETH_IR_TxEndHigh|ETH_IR_TxBufferHigh|
    1185                              ETH_IR_TxEndLow |ETH_IR_TxBufferLow);
    1186   GTeth_tx_cleanup(sc, GE_TXPRIO_HI, op == GE_WHACK_STOP);
     1130                             ETH_IR_TxEndLow |ETH_IR_TxBufferLow);
     1131  GTeth_tx_cleanup(sc);
    11871132
    11881133  sc->arpcom.ac_if.if_timer = 0;
    1189   if (GTeth_debug>0) printk(")");
    1190 }
    1191 
     1134}
    11921135
    11931136/* TOCHECK : Should it be about rx or tx ? */
     
    12281171  add1 = ((add1 & 0x00aaaaaa) >> 1) | ((add1 & 0x00555555) << 1);
    12291172
    1230   if (GTeth_debug>0) printk("eaddr= %s add1:%x add0:%x\n", ether_sprintf(eaddr), add1, add0);
     1173#ifdef GT_DEBUG
     1174  printk("eaddr= %s add1:%x add0:%x\n", ether_sprintf1(eaddr), add1, add0);
     1175#endif
    12311176   
    12321177  /*
     
    12511196      */
    12521197     result |= (add0 & ~3) << 7;        /* excess bits will be masked */
    1253      if (GTeth_debug>0) printk("hash result %x  ", result & 0x7fff);
     1198#ifdef GT_DEBUG
     1199     printk("hash result %x  ", result & 0x7fff);
     1200#endif
    12541201  } else {
    12551202#define TRIBITFLIP      073516240       /* yes its in octal */
     
    12751222     result |= ((TRIBITFLIP >> (((add0 >> 0) & 7) * 3)) & 7) << 12;
    12761223     result |= ((TRIBITFLIP >> (((add0 >> 3) & 7) * 3)) & 7) << 9;
    1277      if (GTeth_debug>5) printk("1(%#x)", result);
    1278   }
    1279   if (GTeth_debug>0) printk(")");
     1224#ifdef GT_DEBUG
     1225     printk("1(%#x)", result);
     1226#endif
     1227  }
     1228#ifdef GT_DEBUG
     1229  printk(")");
     1230#endif
     1231
    12801232  /* 1/2K address filtering (MOTLoad default )? ->16KB memory required
    12811233   * or 8k address filtering ? -> 256KB memory required
     
    12931245  int maybe_hash = 0;
    12941246
    1295   if (GTeth_debug>0) printk("GTeth_hash_entry_op(prio %d ", prio);
     1247#ifdef GT_DEBUG
     1248  printk("GTeth_hash_entry_op(prio %d ", prio);
     1249#endif
    12961250
    12971251  hash = GTeth_hash_compute(sc, eaddr);
     
    13001254        rtems_panic("hashtable == NULL!");
    13011255  }
    1302   if (GTeth_debug>0) printk("Hash computed %x eaddr %s\n", hash,ether_sprintf(eaddr));
    1303 
     1256#ifdef GT_DEBUG
     1257  printk("Hash computed %x eaddr %s\n", hash,ether_sprintf1(eaddr));
     1258#endif
    13041259
    13051260  /*
     
    13211276  hash &= (sc->sc_hashmask / sizeof(he));
    13221277
     1278#ifdef GT_DEBUG
    13231279  if (GTeth_debug>0) {
    13241280    unsigned val1, val2;
     
    13261282    val1= he & 0xffffffff;
    13271283    val2= (he >>32) & 0xffffffff;
    1328     printk("Hash addr value %x%x, entry %x\n",val2,val1, hash);
    1329   }
     1284    printk("Hash addr value %x%x, entry %x\n",val2,val1, hash);
     1285  }
     1286#endif
    13301287
    13311288  for (limit = HSH_LIMIT; limit > 0 ; --limit) {
     
    14251382  int error;
    14261383
    1427   if (GTeth_debug>0) printk( "GTeth_hash_fill(");
     1384#ifdef GT_DEBUG
     1385  printk( "GTeth_hash_fill(");
     1386#endif
    14281387  error = GTeth_hash_entry_op(sc,GE_HASH_ADD,GE_RXPRIO_HI,sc->arpcom.ac_enaddr);
    14291388
     
    14531412    ETHER_NEXT_MULTI(step, enm);
    14541413  }
    1455   if (GTeth_debug>0) printk(")\n");
     1414#ifdef GT_DEBUG
     1415  printk(")\n");
     1416#endif
    14561417  return error;
    14571418}
     
    14761437
    14771438  memset((void *)sc->sc_hashtable, 0,HASH_DRAM_SIZE);
    1478   if (GTeth_debug>0)
    1479     printk("hashtable addr:%x, mask %x)\n", sc->sc_hashtable,sc->sc_hashmask);
     1439#ifdef GT_DEBUG
     1440  printk("hashtable addr:%x, mask %x)\n", sc->sc_hashtable,sc->sc_hashmask);
     1441#endif
    14801442}
    14811443
     
    15491511
    15501512#ifndef GE_NORX
    1551      if (events & RX_EVENT) GT64260eth_rx(sc,GE_RXPRIO_HI);
     1513     if (events & RX_EVENT) GT64260eth_rx(sc);
     1514#endif
     1515#if 0
     1516     printk("%x ", inb(ETH0_EPSR));
     1517     if ( ((i++) % 15)==0) printk("\n");
    15521518#endif
    15531519
    15541520     /* clean up and try sending packets */
    15551521     do {
    1556 #if 1
     1522#if 0
    15571523        if (gpp_int_error!=0) {
    15581524           printk("GPP interrupt error %d\n", gpp_int_error);
     
    15601526        }
    15611527#endif
    1562          if (sc->txq_nactive) GTeth_txq_done(sc, GE_TXPRIO_HI);
     1528         if (sc->txq_nactive) GTeth_txq_done(sc);
    15631529
    15641530         while (sc->txq_free>0) {
     
    15671533              IF_DEQUEUE(&ifp->if_snd,m);
    15681534              if (m==0) break;
    1569               GT64260eth_sendpacket(sc, m, GE_TXPRIO_HI);
     1535              GT64260eth_sendpacket(sc, m);
    15701536           }
    15711537           else {
    1572              if (txq_high_limit(sc))
    1573                  break;
     1538              GTeth_txq_done(sc);
     1539              break;
    15741540           }
    15751541         }
  • c/src/lib/libbsp/powerpc/mvme5500/pci/detect_host_bridge.c

    rf321fdc8 r54cb48f  
    2929{
    3030  unsigned int pcidata, pcidata1;
    31   int PciNumber;
     31  int PciLocal, busNumber=0;
    3232 
    3333  /* On the mvme5500 board, the GT64260B system controller had the MCP
     
    3636   */
    3737  if (enableMCP) return(-1);
    38   for (PciNumber=0; PciNumber<1; PciNumber++) {
    39      PCIx_read_config_dword(PciNumber, 0,
     38  for (PciLocal=0; PciLocal<1; PciLocal++ ) {
     39     pci_read_config_dword(busNumber,
    4040                        0,
    4141                        0,
    42                 PCI0_COMMAND+(PciNumber * 0x80),
     42                        PCI_COMMAND,
    4343                        &pcidata);
    4444
     
    5353    pcidata1 |= PCI_STATUS_CLRERR_MASK;
    5454    pcidata1 |= 0x140;
    55     PCIx_write_config_dword(PciNumber, 0,
     55    pci_write_config_dword(busNumber,
    5656                               0,
    5757                               0,
    58                           PCI0_COMMAND+(PciNumber * 0x80),
     58                          PCI_COMMAND,
    5959                          pcidata1);
    6060
    61     PCIx_read_config_dword(PciNumber, 0,
     61    pci_read_config_dword(busNumber,
    6262                               0,
    6363                               0,
    64                           PCI0_COMMAND+(PciNumber * 0x80),
     64                          PCI_COMMAND,
    6565                          &pcidata1);
    6666
     
    6868                        pcidata1);
    6969    if (pcidata1 & HOSTBRIDGET_ERROR) printk("BSP_clear_hostbridge_errors(): unable to clear pending hostbridge errors\n");
     70    busNumber += BSP_MAX_PCI_BUS_ON_PCI0;
    7071  }
    7172  return(pcidata &  HOSTBRIDGET_ERROR);
  • c/src/lib/libbsp/powerpc/mvme5500/pci/gtpcireg.h

    rf321fdc8 r54cb48f  
    3838 */
    3939#define PCI_ARBCTL_EN   (1<<31)
     40
     41#define  PCI_COMMAND_SB_DIS     0x2000  /* PCI configuration read will stop
     42                                         * acting as sync barrier transactin
     43                                         */
     44
     45#define PCI_MEM_BASE_ADDR PCI_BASE_ADDRESS_4
     46
     47#define PCI_IO_BASE_ADDR  PCI_BASE_ADDRESS_5
     48
     49#define  PCI_STATUS_CLRERR_MASK 0xf9000000 /* <SKF> */
    4050
    4151#define PCI_BARE_IntMemEn     0x200
     
    8393
    8494#define PCI0_CMD_CNTL                           0xc00
    85 #define PCI0_CONFIG_ADDR                        0xcf8
    86 #define PCI0_CONFIG_DATA                        0xcfc
    8795
    8896#define PCI1_P2P_CONFIG                         0x1d94
  • c/src/lib/libbsp/powerpc/mvme5500/pci/pci.c

    rf321fdc8 r54cb48f  
    1212 *  The license and distribution terms for this file may be
    1313 *  found in the file LICENSE in this distribution or at
    14  *  http://www.rtems.com/license/LICENSE.
    15  *
    16  *  $Id$
     14 *  http://www.rtems.com/rtems/license.html.
     15 *
     16 *  pci.c,v 1.2 2002/05/14 17:10:16 joel Exp
    1717 *
    1818 *  Copyright 2004, Brookhaven National Laboratory and
     
    2020 *   - modified and added support for MVME5500 board
    2121 *   - added 2nd PCI support for the mvme5500/GT64260 PCI bridge
    22  *
     22 *   - added bus support for the expansion of PMCSpan, thanks to
     23 *     Peter Dufault (dufault@hda.com) for inputs.
    2324 */
    2425#define PCI_MAIN
     
    3536
    3637#define PCI_DEBUG 0
    37 #define PCI_PRINT 1
     38#define PCI_PRINT 0
     39
     40/* allow for overriding these definitions */
     41#ifndef PCI_CONFIG_ADDR
     42#define PCI_CONFIG_ADDR                 0xcf8
     43#endif
     44#ifndef PCI_CONFIG_DATA
     45#define PCI_CONFIG_DATA                 0xcfc
     46#endif
     47
     48#ifndef PCI1_CONFIG_ADDR
     49#define PCI1_CONFIG_ADDR                0xc78
     50#endif
     51#ifndef PCI1_CONFIG_DATA
     52#define PCI1_CONFIG_DATA                0xc7c
     53#endif
    3854
    3955#define PCI_INVALID_VENDORDEVICEID      0xffffffff
     
    4157#define HOSTBRIDGET_ERROR               0xf0000000
    4258
     59/* define a shortcut */
     60#define pci     BSP_pci_configuration
     61
    4362typedef unsigned char unchar;
    44 
    45 #define MAX_NUM_PCI_DEVICES     20
    46 
    4763static int                numPCIDevs=0;
    48 extern void PCI_interface(), pciAccessInit();
     64extern void pci_interface();
    4965
    5066/* Pack RegNum,FuncNum,DevNum,BusNum,and ConfigEnable for
     
    6177/* Please note that PCI0 and PCI1 does not correlate with the busNum 0 and 1.
    6278 */
    63 int PCIx_read_config_byte(int npci, unchar bus, unchar dev,
    64 unchar func, unchar offset, unchar *val)
    65 {
     79static int direct_pci_read_config_byte(unchar bus,unchar dev,unchar func,
     80unchar offset,unchar *val)
     81{
     82  volatile unsigned char *config_addr, *config_data;
     83
     84  if (bus>= BSP_MAX_PCI_BUS_ON_PCI0) {
     85     bus-=BSP_MAX_PCI_BUS_ON_PCI0;
     86     config_addr = (volatile unsigned char*) PCI1_CONFIG_ADDR;
     87     config_data = (volatile unsigned char*) PCI1_CONFIG_DATA;
     88  }
     89  else {
     90     config_addr = pci.pci_config_addr;
     91     config_data = pci.pci_config_data;
     92  }
    6693  *val = 0xff;
    6794  if (offset & ~0xff) return PCIBIOS_BAD_REGISTER_NUMBER;
    68   outl(pciConfigPack(bus,dev,func,offset),BSP_pci_config[npci].pci_config_addr);
    69   *val = inb(BSP_pci_config[npci].pci_config_data + (offset&3));
    70   return PCIBIOS_SUCCESSFUL;
    71 }
    72 
    73 int PCIx_read_config_word(int npci, unchar bus, unchar dev,
     95#if 0
     96  printk("addr %x, data %x, pack %x \n", config_addr,
     97    config_data,pciConfigPack(bus,dev,func,offset));
     98#endif
     99  outl(pciConfigPack(bus,dev,func,offset),config_addr);
     100  *val = inb(config_data + (offset&3));
     101  return PCIBIOS_SUCCESSFUL;
     102}
     103
     104static int direct_pci_read_config_word(unchar bus, unchar dev,
    74105unchar func, unchar offset, unsigned short *val)
    75106{
     107  volatile unsigned char *config_addr, *config_data;
     108
     109  if (bus>= BSP_MAX_PCI_BUS_ON_PCI0) {
     110     bus-=BSP_MAX_PCI_BUS_ON_PCI0;
     111     config_addr = (volatile unsigned char*) PCI1_CONFIG_ADDR;
     112     config_data = (volatile unsigned char*) PCI1_CONFIG_DATA;
     113  }
     114  else {
     115     config_addr = (volatile unsigned char*) pci.pci_config_addr;
     116     config_data = (volatile unsigned char*) pci.pci_config_data;
     117  }
     118
    76119  *val = 0xffff;
    77120  if ((offset&1)|| (offset & ~0xff)) return PCIBIOS_BAD_REGISTER_NUMBER;
    78   outl(pciConfigPack(bus,dev,func,offset),BSP_pci_config[npci].pci_config_addr);
    79   *val = inw(BSP_pci_config[npci].pci_config_data + (offset&2));
    80   return PCIBIOS_SUCCESSFUL;
    81 }
    82 
    83 int PCIx_read_config_dword(int npci, unchar bus, unchar dev,
     121#if 0
     122  printk("addr %x, data %x, pack %x \n", config_addr,
     123    config_data,pciConfigPack(bus,dev,func,offset));
     124#endif
     125  outl(pciConfigPack(bus,dev,func,offset),config_addr);
     126  *val = inw(config_data + (offset&2));
     127  return PCIBIOS_SUCCESSFUL;
     128}
     129
     130static int direct_pci_read_config_dword(unchar bus, unchar dev,
    84131unchar func, unchar offset, unsigned int *val)
    85132{
     133  volatile unsigned char *config_addr, *config_data;
     134
     135  if (bus>= BSP_MAX_PCI_BUS_ON_PCI0) {
     136     bus-=BSP_MAX_PCI_BUS_ON_PCI0;
     137     config_addr = (volatile unsigned char*) PCI1_CONFIG_ADDR;
     138     config_data = (volatile unsigned char*) PCI1_CONFIG_DATA;
     139  }
     140  else {
     141     config_addr = (volatile unsigned char*) pci.pci_config_addr;
     142     config_data = (volatile unsigned char*) pci.pci_config_data;
     143  }
     144
    86145  *val = 0xffffffff;
    87146  if ((offset&3)|| (offset & ~0xff)) return PCIBIOS_BAD_REGISTER_NUMBER;
    88147#if 0
    89   printk("addr %x, data %x, pack %x \n", BSP_pci_config[npci].pci_config_addr,
    90     BSP_pci_config[npci].pci_config_data,pciConfigPack(bus,dev,func,offset));
    91 #endif
    92   outl(pciConfigPack(bus,dev,func,offset),BSP_pci_config[npci].pci_config_addr);
    93   *val = inl(BSP_pci_config[npci].pci_config_data);
    94   return PCIBIOS_SUCCESSFUL;
    95 }
    96 
    97 int PCIx_write_config_byte(int npci, unchar bus, unchar dev,
    98 unchar func, unchar offset, unchar val)
    99 {
     148  printk("addr %x, data %x, pack %x \n", config_addr,
     149    pci.pci_config_data,pciConfigPack(bus,dev,func,offset));
     150#endif
     151  outl(pciConfigPack(bus,dev,func,offset),config_addr);
     152  *val = inl(config_data);
     153  return PCIBIOS_SUCCESSFUL;
     154}
     155
     156static int direct_pci_write_config_byte(unchar bus, unchar dev,unchar func, unchar offset, unchar val)
     157{
     158  volatile unsigned char *config_addr, *config_data;
     159
     160  if (bus>= BSP_MAX_PCI_BUS_ON_PCI0) {
     161     bus-=BSP_MAX_PCI_BUS_ON_PCI0;
     162     config_addr = (volatile unsigned char*) PCI1_CONFIG_ADDR;
     163     config_data = (volatile unsigned char*) PCI1_CONFIG_DATA;
     164  }
     165  else {
     166     config_addr = pci.pci_config_addr;
     167     config_data = pci.pci_config_data;
     168  }
     169
    100170  if (offset & ~0xff) return PCIBIOS_BAD_REGISTER_NUMBER;
    101 
    102   outl(pciConfigPack(bus,dev,func,offset),BSP_pci_config[npci].pci_config_addr);
    103   outb(val, BSP_pci_config[npci].pci_config_data + (offset&3));
    104   return PCIBIOS_SUCCESSFUL;
    105 }
    106 
    107 int PCIx_write_config_word(int npci, unchar bus, unchar dev,
    108 unchar func, unchar offset, unsigned short val)
    109 {
     171#if 0
     172  printk("addr %x, data %x, pack %x \n", config_addr,
     173    config_data,pciConfigPack(bus,dev,func,offset));
     174#endif
     175
     176  outl(pciConfigPack(bus,dev,func,offset), config_addr);
     177  outb(val, config_data + (offset&3));
     178  return PCIBIOS_SUCCESSFUL;
     179}
     180
     181static int direct_pci_write_config_word(unchar bus, unchar dev,unchar func, unchar offset, unsigned short val)
     182{
     183  volatile unsigned char *config_addr, *config_data;
     184
     185  if (bus>= BSP_MAX_PCI_BUS_ON_PCI0) {
     186     bus-=BSP_MAX_PCI_BUS_ON_PCI0;
     187     config_addr = (volatile unsigned char*) PCI1_CONFIG_ADDR;
     188     config_data = (volatile unsigned char*) PCI1_CONFIG_DATA;
     189  }
     190  else {
     191     config_addr = (volatile unsigned char*) pci.pci_config_addr;
     192     config_data = (volatile unsigned char*) pci.pci_config_data;
     193  }
     194
    110195  if ((offset&1)|| (offset & ~0xff)) return PCIBIOS_BAD_REGISTER_NUMBER;
    111   outl(pciConfigPack(bus,dev,func,offset),BSP_pci_config[npci].pci_config_addr);
    112   outw(val, BSP_pci_config[npci].pci_config_data + (offset&3));
    113   return PCIBIOS_SUCCESSFUL;
    114 }
    115 
    116 int PCIx_write_config_dword(int npci,unchar bus,unchar dev,
    117 unchar func, unchar offset, unsigned int val)
    118 {
     196#if 0
     197  printk("addr %x, data %x, pack %x \n", config_addr,
     198    config_data,pciConfigPack(bus,dev,func,offset));
     199#endif
     200  outl(pciConfigPack(bus,dev,func,offset),config_addr);
     201  outw(val, config_data + (offset&3));
     202  return PCIBIOS_SUCCESSFUL;
     203}
     204
     205static int direct_pci_write_config_dword(unchar bus,unchar dev,unchar func, unchar offset, unsigned int val)
     206{
     207  volatile unsigned char *config_addr, *config_data;
     208
     209  if (bus>= BSP_MAX_PCI_BUS_ON_PCI0) {
     210     bus-=BSP_MAX_PCI_BUS_ON_PCI0;
     211     config_addr = (volatile unsigned char *) PCI1_CONFIG_ADDR;
     212     config_data = (volatile unsigned char *) PCI1_CONFIG_DATA;
     213  }
     214  else {
     215     config_addr = (volatile unsigned char*) pci.pci_config_addr;
     216     config_data = (volatile unsigned char*) pci.pci_config_data;
     217  }
     218
    119219  if ((offset&3)|| (offset & ~0xff)) return PCIBIOS_BAD_REGISTER_NUMBER;
    120220#if 0
    121   printk("addr %x, data %x, pack %x \n", BSP_pci_config[npci].pci_config_addr,
    122     BSP_pci_config[npci].pci_config_data,pciConfigPack(bus,dev,func,offset));
    123 #endif
    124   outl(pciConfigPack(bus,dev,func,offset),BSP_pci_config[npci].pci_config_addr);
    125   outl(val,BSP_pci_config[npci].pci_config_data);
    126   return PCIBIOS_SUCCESSFUL;
    127 }
    128 
    129 /* backwards compatible with other PPC board for the vmeUniverse.c
    130  * Note: We must override the default with these in pci.h
    131  */
    132 int pci_bsp_read_config_byte(unchar bus, unchar dev,unchar func,unchar offset,
    133 unchar *val)
    134 {
    135   return(PCIx_read_config_byte(0, bus, dev, func, offset, val));
    136 }
    137 
    138 int pci_bsp_read_config_word(unchar bus, unchar dev,
    139 unchar func, unchar offset, unsigned short *val)
    140 {
    141   return(PCIx_read_config_word(0, bus, dev, func, offset, val));
    142 }
    143 
    144 int pci_bsp_read_config_dword(unchar bus, unchar dev,
    145 unchar func, unchar offset, unsigned int *val)
    146 {
    147   return(PCIx_read_config_dword(0, bus, dev, func, offset, val));
    148 }
    149 
    150 int pci_bsp_write_config_byte(unchar bus, unchar dev,
    151 unchar func, unchar offset, unchar val)
    152 {
    153   return(PCIx_write_config_byte(0, bus, dev, func, offset, val));
    154 }
    155 
    156 int pci_bsp_write_config_word(unchar bus, unchar dev,
    157 unchar func, unchar offset, unsigned short val)
    158 {
    159   return(PCIx_write_config_word(0, bus, dev, func, offset, val));
    160 }
    161 
    162 int pci_bsp_write_config_dword(unchar bus,unchar dev,
    163 unchar func, unchar offset, unsigned int val)
    164 {
    165   return(PCIx_write_config_dword(0, bus, dev, func, offset, val));
    166 }
    167 
    168 
    169 pci_bsp_config BSP_pci_config[2] = {
    170   {PCI0_CONFIG_ADDR,PCI0_CONFIG_DATA/*,&pci_functions*/},
    171        {PCI1_CONFIG_ADDR,PCI1_CONFIG_DATA/*,&pci_functions*/}
     221  printk("addr %x, data %x, pack %x \n", config_addr,
     222    config_data,pciConfigPack(bus,dev,func,offset));
     223#endif
     224  outl(pciConfigPack(bus,dev,func,offset),config_addr);
     225  outl(val,config_data);
     226  return PCIBIOS_SUCCESSFUL;
     227}
     228
     229const pci_config_access_functions pci_direct_functions = {
     230        direct_pci_read_config_byte,
     231        direct_pci_read_config_word,
     232        direct_pci_read_config_dword,
     233        direct_pci_write_config_byte,
     234        direct_pci_write_config_word,
     235        direct_pci_write_config_dword
    172236};
    173237
     238
     239pci_config BSP_pci_configuration = {(volatile unsigned char*) PCI_CONFIG_ADDR,
     240                         (volatile unsigned char*)PCI_CONFIG_DATA,
     241                                    &pci_direct_functions};
     242
    174243/*
    175  * This routine determines the maximum bus number in the system
     244 * This routine determines the maximum bus number in the system.
     245 * The PCI_SUBORDINATE_BUS is not supported in GT6426xAB. Thus,
     246 * it's not used.
     247 *
    176248 */
    177249int pci_initialize()
    178250{
    179   int PciNumber;
     251  int deviceFound;
    180252  unchar ucBusNumber, ucSlotNumber, ucFnNumber, ucNumFuncs;
    181253  unsigned int ulHeader;
    182   unsigned int pcidata, ulDeviceID;
    183 #if PCI_DEBUG
    184   unsigned int data, pcidata, ulClass;
    185   unsigned short sdata;
    186 #endif
    187 
    188   PCI_interface();
     254  unsigned int pcidata, ulClass, ulDeviceID;
     255
     256  pci_interface();
    189257 
    190258  /*
    191    * Scan PCI0 and PCI1 bus0
     259   * Scan PCI0 and PCI1 buses
    192260   */
    193   for (PciNumber=0; PciNumber < 2; PciNumber++) {
    194     pciAccessInit(PciNumber);
    195     for (ucBusNumber=0; ucBusNumber< 2; ucBusNumber++) {
     261  for (ucBusNumber=0; ucBusNumber<BSP_MAX_PCI_BUS; ucBusNumber++) {
     262    deviceFound=0;
    196263    for (ucSlotNumber=0;ucSlotNumber<PCI_MAX_DEVICES;ucSlotNumber++) {
    197264      ucFnNumber = 0;
    198       PCIx_read_config_dword(PciNumber, ucBusNumber,
     265      pci_read_config_dword(ucBusNumber,
    199266                                ucSlotNumber,
    200267                                0,
    201                                 PCI0_VENDOR_ID,
     268                                PCI_VENDOR_ID,
    202269                                &ulDeviceID);
    203270
     
    207274      }
    208275
    209       if (++numPCIDevs > MAX_NUM_PCI_DEVICES) {
    210          BSP_panic("Too many PCI devices found; increase MAX_NUM_PCI_DEVICES in pcicache.c\n");
     276      if (++numPCIDevs > PCI_MAX_DEVICES) {
     277         BSP_panic("Too many PCI devices found; increase PCI_MAX_DEVICES in pci.h\n");
    211278      }
    212279
     280      if (!deviceFound) deviceFound=1;
    213281      switch(ulDeviceID) {
    214282        case (PCI_VENDOR_ID_MARVELL+(PCI_DEVICE_ID_MARVELL_GT6426xAB<<16)):
    215283#if PCI_PRINT
    216           printk("Marvell GT6426xA/B hostbridge detected at PCI%d bus%d slot%d\n",
    217                  PciNumber,ucBusNumber,ucSlotNumber);
    218 #endif
    219           ucMaxPCIBus ++;
     284          printk("Marvell GT6426xA/B hostbridge detected at bus%d slot%d\n",
     285                 ucBusNumber,ucSlotNumber);
     286#endif
    220287          break;
    221288        case (PCI_VENDOR_ID_PLX2+(PCI_DEVICE_ID_PLX2_PCI6154_HB2<<16)):
    222289#if PCI_PRINT
    223           printk("PLX PCI6154 PCI-PCI bridge detected at PCI%d bus%d slot%d\n",
    224                  PciNumber,ucBusNumber,ucSlotNumber);
    225 #endif
    226           ucMaxPCIBus ++;
     290          printk("PLX PCI6154 PCI-PCI bridge detected at bus%d slot%d\n",
     291                 ucBusNumber,ucSlotNumber);
     292#endif
    227293          break;
    228294        case PCI_VENDOR_ID_TUNDRA:
    229295#if PCI_PRINT
    230           printk("TUNDRA PCI-VME bridge detected at PCI%d bus%d slot%d\n",
    231                  PciNumber,ucBusNumber,ucSlotNumber);
    232 #endif
    233           ucMaxPCIBus ++;
     296          printk("TUNDRA PCI-VME bridge detected at bus%d slot%d\n",
     297                 ucBusNumber,ucSlotNumber);
     298#endif
    234299          break;
    235300      case (PCI_VENDOR_ID_INTEL+(PCI_DEVICE_INTEL_82544EI_COPPER<<16)):
    236301#if PCI_PRINT
    237           printk("INTEL 82544EI COPPER network controller detected at PCI%d bus%d slot%d\n",
    238                  PciNumber,ucBusNumber,ucSlotNumber);
    239 #endif
    240           ucMaxPCIBus ++;
     302          printk("INTEL 82544EI COPPER network controller detected at bus%d slot%d\n",
     303                 ucBusNumber,ucSlotNumber);
     304#endif
    241305          break;
    242         default :
    243 #if PCI_PRINT
    244           printk("PCI%d Bus%d Slot%d DeviceID 0x%x \n",
    245              PciNumber,ucBusNumber,ucSlotNumber, ulDeviceID);
    246 #endif
     306      case (PCI_VENDOR_ID_DEC+(PCI_DEVICE_ID_DEC_21150<<16)):
     307 #if PCI_PRINT
     308          printk("DEC21150 PCI-PCI bridge detected at bus%d slot%d\n",
     309                 ucBusNumber,ucSlotNumber);
     310#endif
     311          break;
     312       default :
     313          printk("BSP unlisted vendor, Bus%d Slot%d DeviceID 0x%x \n",
     314             ucBusNumber,ucSlotNumber, ulDeviceID);
    247315          break;
    248316      }
     317
    249318#if PCI_DEBUG
    250       PCIx_read_config_dword(PciNumber, ucBusNumber,
     319      pci_read_config_dword(ucBusNumber,
    251320                          ucSlotNumber,
    252321                          0,
    253                           PCI0_BASE_ADDRESS_0,
     322                          PCI_BASE_ADDRESS_0,
    254323                          &data);
    255       printk("PCI%d_BASE_ADDRESS_0 0x%x \n",PciNumber, data); 
    256       PCIx_read_config_dword(PciNumber, ucBusNumber,
     324      printk("Bus%d BASE_ADDRESS_0 0x%x \n",ucBusNumber, data); 
     325      pci_read_config_dword(ucBusNumber,
    257326                          ucSlotNumber,
    258327                          0,
    259                           PCI0_BASE_ADDRESS_1,
     328                          PCI_BASE_ADDRESS_1,
    260329                          &data);
    261       printk("PCI%d_BASE_ADDRESS_1 0x%x \n",PciNumber, data);
    262       PCIx_read_config_dword(PciNumber, ucBusNumber,
     330      printk("Bus%d BASE_ADDRESS_1 0x%x \n",ucBusNumber, data);
     331      pci_read_config_dword(ucBusNumber,
    263332                          ucSlotNumber,
    264333                          0,
    265                           PCI0_BASE_ADDRESS_2,
     334                          PCI_BASE_ADDRESS_2,
    266335                          &data);
    267       printk("PCI%d_BASE_ADDRESS_2 0x%x \n",PciNumber, data);
    268 
    269       PCIx_read_config_dword(PciNumber, ucBusNumber,
     336      printk("Bus%d BASE_ADDRESS_2 0x%x \n", ucBusNumber, data);
     337
     338      pci_read_config_dword(ucBusNumber,
    270339                          ucSlotNumber,
    271340                          0,
    272                           PCI0_BASE_ADDRESS_3,
     341                          PCI_BASE_ADDRESS_3,
    273342                          &data);
    274       printk("PCI%d_BASE_ADDRESS_3 0x%x \n",PciNumber, data); 
    275 
    276      PCIx_read_config_word(PciNumber, ucBusNumber,
     343      printk("Bus%d BASE_ADDRESS_3 0x%x \n", ucBusNumber, data); 
     344
     345      pci_read_config_word(ucBusNumber,
    277346                          ucSlotNumber,
    278347                          0,
    279                           PCI0_INTERRUPT_LINE,
     348                          PCI_INTERRUPT_LINE,
    280349                          &sdata);
    281       printk("PCI%d_INTERRUPT_LINE 0x%x \n",PciNumber, sdata); 
     350      printk("Bus%d INTERRUPT_LINE 0x%x \n", ucBusNumber, sdata); 
    282351
    283352      /* We always enable internal memory. */
    284       PCIx_read_config_dword(PciNumber, ucBusNumber,
     353      pci_read_config_dword(ucBusNumber,
    285354                          ucSlotNumber,
    286355                          0,
    287                           PCI0_MEM_BASE_ADDR,
     356                          PCI_MEM_BASE_ADDR,
    288357                          &pcidata);
    289       printk("PCI%d_MEM_BASE_ADDR 0x%x \n", PciNumber,pcidata);
     358      printk("Bus%d MEM_BASE_ADDR 0x%x \n", ucBusNumber,pcidata);
    290359
    291360      /* We always enable internal IO. */
    292       PCIx_read_config_dword(PciNumber, ucBusNumber,
     361      pci_read_config_dword(ucBusNumber,
    293362                          ucSlotNumber,
    294363                          0,
    295                           PCI0_IO_BASE_ADDR,
     364                          PCI_IO_BASE_ADDR,
    296365                          &pcidata);
    297       printk("PCI%d_IO_BASE_ADDR 0x%x \n", PciNumber,pcidata);
    298 #endif
    299 
    300       PCIx_read_config_dword(PciNumber, ucBusNumber,
     366      printk("Bus%d IO_BASE_ADDR 0x%x \n", ucBusNumber,pcidata);
     367#endif
     368
     369      pci_read_config_dword(ucBusNumber,
    301370                          ucSlotNumber,
    302371                          0,
    303                           PCI0_CACHE_LINE_SIZE,
     372                          PCI_CACHE_LINE_SIZE,
    304373                          &ulHeader);
    305374      if ((ulHeader>>16)&PCI_MULTI_FUNCTION)
     
    309378
    310379#if PCI_DEBUG
    311       printk("PCI%d Slot 0x%x HEADER/LAT/CACHE 0x%x \n",
    312              PciNumber,ucSlotNumber, ulHeader);   
     380      printk("Bus%d Slot 0x%x HEADER/LAT/CACHE 0x%x \n",
     381             ucBusNumber, ucSlotNumber, ulHeader);   
     382#endif
    313383
    314384      for (ucFnNumber=1;ucFnNumber<ucNumFuncs;ucFnNumber++) {
    315           PCIx_read_config_dword(PciNumber, ucBusNumber,
     385          pci_read_config_dword(ucBusNumber,
    316386                                  ucSlotNumber,
    317387                                  ucFnNumber,
    318                                   PCI0_VENDOR_ID,
     388                                  PCI_VENDOR_ID,
    319389                                  &ulDeviceID);
    320390          if (ulDeviceID==PCI_INVALID_VENDORDEVICEID) {
     
    322392             continue;
    323393          }
    324           if (++numPCIDevs > MAX_NUM_PCI_DEVICES) {
    325              BSP_panic("Too many PCI devices found; increase MAX_NUM_PCI_DEVICES in pcicache.c\n");
    326           }
    327394
    328395         /* This slot/function has a device fitted.*/
    329          PCIx_read_config_dword(PciNumber, ucBusNumber,
     396         pci_read_config_dword(ucBusNumber,
    330397                                  ucSlotNumber,
    331398                                  ucFnNumber,
    332                                   PCI0_CLASS_REVISION,
    333                                   &ulClass);     
    334          printk("PCI%d Slot 0x%x Func %d classID 0x%x \n",PciNumber,ucSlotNumber,
     399                                  PCI_CLASS_REVISION,
     400                                  &ulClass);
     401#if PCI_DEBUG   
     402         printk("Bus%d Slot 0x%x Func %d classID 0x%x \n",ucBusNumber,ucSlotNumber,
    335403             ucFnNumber, ulClass);
    336 
    337          ulClass >>= 16;
    338          if (ulClass == PCI_CLASS_GT6426xAB)
    339             printk("GT64260-PCI%d bridge found \n", PciNumber);
     404#endif
     405
    340406      }
    341 #endif
    342       PCIx_read_config_dword(PciNumber, ucBusNumber,
     407
     408      pci_read_config_dword(ucBusNumber,
    343409                               ucSlotNumber,
    344410                               0,
    345                           PCI0_COMMAND,
     411                          PCI_COMMAND,
    346412                          &pcidata);
    347413#if PCI_DEBUG
     
    353419      /* Enable bus,I/O and memory master access. */
    354420      pcidata |= (PCI_COMMAND_MASTER|PCI_COMMAND_IO|PCI_COMMAND_MEMORY);
    355       PCIx_write_config_dword(PciNumber, ucBusNumber,
     421      pci_write_config_dword(ucBusNumber,
    356422                               ucSlotNumber,
    357423                               0,
    358                           PCI0_COMMAND,
     424                          PCI_COMMAND,
    359425                          pcidata);
    360426
    361       PCIx_read_config_dword(PciNumber, ucBusNumber,
     427      pci_read_config_dword(ucBusNumber,
    362428                               ucSlotNumber,
    363429                               0,
    364                           PCI0_COMMAND,
     430                          PCI_COMMAND,
    365431                          &pcidata);
    366432#if PCI_DEBUG     
    367433      printk("Now command/staus 0x%x\n", pcidata);
    368434#endif
    369  
    370435    }
    371     }
    372   } /* PCI number */
    373 
    374   return PCIB_ERR_SUCCESS;
     436    if (deviceFound) ucMaxPCIBus++;
     437  } /* for (ucBusNumber=0; ucBusNumber<BSP_MAX_PCI_BUS; ... */
     438#if PCI_DEBUG
     439  printk("number of PCI buses: %d, numPCIDevs %d\n",
     440         pci_bus_count(), numPCIDevs);
     441#endif
     442  return(0);
     443}
     444
     445void FixupPCI( struct _int_map *bspmap, int (*swizzler)(int,int) )
     446{
    375447}
    376448
  • c/src/lib/libbsp/powerpc/mvme5500/pci/pci.h

    rf321fdc8 r54cb48f  
    1515 *      pci.h,v 1.2 2002/05/14 17:10:16 joel Exp
    1616 *
    17  *      S. Kate Feng : Added vendor/device support for
    18  *      Marvell and PLX. 3/5/2004
    19  *
     17 *      S. Kate Feng : Added support for Marvell and PLX. 3/5/2004.
     18
    2019 */
    2120
    22 #ifndef BSP_PCI_H
    23 #define BSP_PCI_H
     21#ifndef RTEMS_PCI_H
     22#define RTEMS_PCI_H
    2423
    2524#include <rtems/pci.h>
    2625
    27 #define PCI0_VENDOR_ID          0x00    /* 16 bits */
    28 #define PCI0_DEVICE_ID          0x02    /* 16 bits */
    29 #define PCI0_COMMAND            0x04    /* 16 bits */
    30 
    31 #define  PCI_COMMAND_SB_DIS     0x2000  /* PCI configuration read will stop
    32                                          * acting as sync barrier transaction
    33                                          */
    34 #define  PCI_STATUS_CLRERR_MASK 0xf9000000 /* <SKF> */
    35  
    36 #define PCI0_CLASS_REVISION     0x08    /* High 24 bits are class, low 8
    37                                            revision */
    38 #define PCI0_REVISION_ID        0x08    /* Revision ID */
    39 #define PCI0_CLASS_PROG         0x09    /* Reg. Level Programming Interface */
    40 #define PCI0_CLASS_DEVICE       0x0a    /* Device class */
    41 
    42 #define PCI0_CACHE_LINE_SIZE    0x0c    /* 8 bits */
    43 #define PCI0_LATENCY_TIMER      0x0d    /* 8 bits */
    44 #define PCI0_HEADER_TYPE        0x0e    /* 8 bits */
    45 
    46 #define PCI0_CAPABILITY_LIST_POINTER    0x34
    47 
    48 /* 0x38-0x3b are reserved */
    49 #define PCI0_INTERRUPT_LINE     0x3c    /* 8 bits */
    50 #define PCI0_INTERRUPT_PIN      0x3d    /* 8 bits */
    51 #define PCI0_MIN_GNT            0x3e    /* 8 bits */
    52 #define PCI0_MAX_LAT            0x3f    /* 8 bits */
    53 
    54 /*
    55  * Under PCI1, each device has 256 bytes of configuration address space,
    56  * of which the first 64 bytes are standardized as follows:
    57  */
    58 #define PCI1_VENDOR_ID          0x80    /* 16 bits */
    59 #define PCI1_DEVICE_ID          0x82    /* 16 bits */
    60 #define PCI1_COMMAND            0x84    /* 16 bits */
    61 #define PCI1_STATUS             0x86    /* 16 bits */
    62 #define PCI1_CLASS_REVISION     0x88    /* High 24 bits are class, low 8
    63                                            revision */
    64 #define PCI1_REVISION_ID        0x88    /* Revision ID */
    65 #define PCI1_CLASS_PROG         0x89    /* Reg. Level Programming Interface */
    66 #define PCI1_CLASS_DEVICE       0x8a    /* Device class */
    67 
    68 #define PCI1_CACHE_LINE_SIZE    0x8c    /* 8 bits */
    69 #define PCI1_LATENCY_TIMER      0x8d    /* 8 bits */
    70 #define PCI1_HEADER_TYPE        0x8e    /* 8 bits */
    71 #define PCI1_BIST               0x8f    /* 8 bits */
    72 
    73 #define PCI1_BASE_ADDRESS_0     0x90    /* 32 bits */
    74 #define PCI1_BASE_ADDRESS_1     0x94    /* 32 bits [htype 0,1 only] */
    75 #define PCI1_BASE_ADDRESS_2     0x98    /* 32 bits [htype 0 only] */
    76 #define PCI1_BASE_ADDRESS_3     0x9c    /* 32 bits */
    77 #define PCI1_MEM_BASE_ADDR      0xa0    /* 32 bits */
    78 #define PCI1_IO_BASE_ADDR       0xa4    /* 32 bits */
    79 
    80 /* Header type 0 (normal devices) */
    81 #define PCI1_CARDBUS_CIS                0xa8
    82 #define PCI1_SUBSYSTEM_VENDOR_ID        0xac
    83 #define PCI1_SUBSYSTEM_ID               0xae 
    84 #define PCI1_ROM_ADDRESS                0xb0    /* Bits 31..11 are address, 10..1 reserved */
    85 #define PCI1_CAPABILITY_LIST_POINTER    0xb4
    86 
    87 /* 0xb8-0xbb are reserved */
    88 #define PCI1_INTERRUPT_LINE     0xbc    /* 8 bits */
    89 #define PCI1_INTERRUPT_PIN      0xbd    /* 8 bits */
    90 #define PCI1_MIN_GNT            0xbe    /* 8 bits */
    91 #define PCI1_MAX_LAT            0xbf    /* 8 bits */
     26#define PCI_CAPABILITY_LIST_POINTER    0x34  /* <SKF> */
    9227
    9328/* Device classes and subclasses */
    94 #define PCI_CLASS_GT6426xAB             0x0580    /* <SKF> */
    95              
     29#define PCI_CLASS_GT6426xAB_BRIDGE_PCI  0x0580    /* <SKF> */
     30         
    9631/*
    9732 * Vendor and card ID's: sort these numerically according to vendor
     
    10843#define PCI_DEVICE_ID_PLX2_PCI6154_HB2  0x26     /* <SKF> */
    10944
    110 #define PCI_DEVICE_INTEL_82544EI_COPPER 0x1008  /* <SKF> */
     45#define PCI_DEVICE_INTEL_82544EI_COPPER 0x1008  /* <SKF> */
    11146
    112 typedef struct {
    113   unsigned int  pci_config_addr;
    114   unsigned int  pci_config_data;
    115   /*  const pci_config_access_functions*        pci_functions;*/
    116 } pci_bsp_config;
     47struct _pin_routes
     48{
     49      int pin, int_name[4];
     50};
     51struct _int_map
     52{
     53      int bus, slot, opts;
     54      struct _pin_routes pin_route[5];
     55};
    11756
    118 extern pci_bsp_config BSP_pci_config[2];
     57void FixupPCI( struct _int_map *, int (*swizzler)(int,int) );
    11958
    120 #ifndef PCI_MAIN
    121 extern int PCIx_read_config_byte();
    122 extern int PCIx_read_config_word();
    123 extern int PCIx_read_config_dword();
    124 extern int PCIx_write_config_byte();
    125 extern int PCIx_write_config_word();
    126 extern int PCIx_write_config_dword();
    127 #endif
    128 
    129 extern int pci_bsp_read_config_byte(
    130   unsigned char bus,
    131   unsigned char dev,
    132   unsigned char func,
    133   unsigned char offset,
    134   unsigned char *val
    135 );
    136 
    137 extern int pci_bsp_read_config_word(
    138   unsigned char bus,
    139   unsigned char dev,
    140   unsigned char func,
    141   unsigned char offset,
    142   unsigned short *val
    143 );
    144 
    145 extern int pci_bsp_read_config_dword(
    146   unsigned char bus,
    147   unsigned char dev,
    148   unsigned char func,
    149   unsigned char offset,
    150   unsigned int *val
    151 );
    152 
    153 extern int pci_bsp_write_config_byte(
    154   unchar bus,
    155   unchar dev,
    156   unchar func,
    157   unchar offset,
    158   unchar val
    159 );
    160 
    161 extern int pci_bsp_write_config_word(
    162   unchar bus,
    163   unchar dev,
    164   unchar func,
    165   unchar offset,
    166   unsigned short val
    167 );
    168 
    169 extern int pci_bsp_write_config_dword(
    170   unchar bus,
    171   unchar dev,
    172   unchar func,
    173   unchar offset,
    174   unsigned int val
    175 );
    176 
    177 
    178 /*
    179  * Override the default pci_read_config... for vmeUniverse.c
    180  */
    181 #define BSP_PCI_CONFIG_IN_LONG  pci_bsp_read_config_dword
    182 #define BSP_PCI_CONFIG_IN_BYTE  pci_bsp_read_config_byte
    183 
    184 
    185 int BSP_PCIxFindDevice(unsigned short vendorid, unsigned short deviceid,
    186                        int instance, int pciNum, int *pbus, int *pdev, int *pfun );
    187 
    188 #endif /* BSP_PCI_H */
     59#endif /* RTEMS_PCI_H */
  • c/src/lib/libbsp/powerpc/mvme5500/pci/pci_interface.c

    rf321fdc8 r54cb48f  
    8383#define ADDR_PIPELINE 0x00020000
    8484
    85 void PCI_interface()
     85void  pciAccessInit();
     86
     87void pci_interface()
    8688{
    8789  unsigned int data;
     
    114116  outl(0x07fff600, CNT_SYNC_REG);
    115117#else
    116   outl(inl(PCI0_CMD_CNTL)|PCI_COMMAND_SB_DIS, PCI0_CMD_CNTL);
     118  outl(inl(PCI_CMD_CNTL)|PCI_COMMAND_SB_DIS, PCI_CMD_CNTL);
    117119#endif
    118120
     
    120122  outl(0x3fffff, 0xc28);
    121123
     124  pciAccessInit();
    122125}
    123 
    124126/* Use MOTLoad default for Writeback Priority and Buffer Depth
    125127 */
    126 void pciAccessInit(int PciNum)
     128void pciAccessInit()
    127129{
    128   unsigned int data;
     130  unsigned int PciLocal, data;
    129131
    130   /* MOTLoad combines the two banks of SDRAM into
    131    * one PCI access control because the top = 0x1ff
    132    */
    133   data = inl(GT_SCS0_Low_Decode) & 0xfff;
    134   data |= PCI_ACCCTLBASEL_VALUE;
    135   data &= ~0x300000;
    136   outl(data, PCI0_ACCESS_CNTL_BASE0_LOW+(PciNum * 0x80));
     132  for (PciLocal=0; PciLocal < 2; PciLocal++) {
     133    /* MOTLoad combines the two banks of SDRAM into
     134     * one PCI access control because the top = 0x1ff
     135     */
     136    data = inl(GT_SCS0_Low_Decode) & 0xfff;
     137    data |= PCI_ACCCTLBASEL_VALUE;
     138    data &= ~0x300000;
     139    outl(data, PCI0_ACCESS_CNTL_BASE0_LOW+(PciLocal * 0x80));
    137140#if PCI_DEBUG
    138   printk("PCI%d_ACCESS_CNTL_BASE0_LOW 0x%x\n",PciNum,inl(PCI0_ACCESS_CNTL_BASE0_LOW+(PciNum * 0x80)));
     141    printk("PCI%d_ACCESS_CNTL_BASE0_LOW 0x%x\n",PciLocal,inl(PCI_ACCESS_CNTL_BASE0_LOW+(PciLocal * 0x80)));
    139142#endif
    140 
     143  }
    141144}
    142145
     
    167170{
    168171  unsigned char data;
     172  unsigned char bus=0;
    169173
    170   PCIx_read_config_byte(pci_num, 0,0,0,4, &data);
     174  if (pci_num) bus += BSP_MAX_PCI_BUS_ON_PCI0;
     175  pci_read_config_byte(bus,0,0,4, &data);
    171176}
  • c/src/lib/libbsp/powerpc/mvme5500/pci/pcifinddevice.c

    rf321fdc8 r54cb48f  
    77 *
    88 *
    9  * Kate Feng <feng1@bnl.gov>, modified it to support
    10  * the mvme5500 board and provided glues to Till's vmeUniverse.c.
    11  *
     9 * Kate Feng <feng1@bnl.gov>, modified it to support the mvme5500 board.
     10 *
    1211 */
    1312
     
    1514#define PCI_MULTI_FUNCTION                      0x80
    1615
    17 /*#define PCI_DEBUG*/
    1816
    1917#include <bsp/pci.h>
    2018#include <rtems/bspIo.h>
     19#include <bsp.h>
    2120
    22 int BSP_PCIxFindDevice(unsigned short vendorid, unsigned short deviceid,
    23      int instance, int pciNum, int *pbus, int *pdev, int *pfun )
     21int BSP_pciDebug=0;
     22
     23int BSP_pciFindDevicePrint(unsigned short vendorid, unsigned short deviceid,
     24                   int instance, int *pbus, int *pdev, int *pfun )
     25{
     26  int x;
     27
     28  BSP_pciDebug = 1;
     29  x=pci_find_device(vendorid, deviceid, instance, pbus, pdev, pfun );
     30  BSP_pciDebug = 0;
     31
     32  return 0;
     33
     34
     35int pci_find_device( unsigned short vendorid, unsigned short deviceid,
     36                   int instance, int *pbus, int *pdev, int *pfun )
    2437{
    2538  unsigned int d;
     
    2740  unsigned char bus,dev,fun,hd;
    2841
    29   for (bus=0; bus<2; bus++) {
     42  for (bus=0; bus<BSP_MAX_PCI_BUS; bus++) {
    3043      for (dev=0; dev<PCI_MAX_DEVICES; dev++) {
    31           PCIx_read_config_byte(pciNum, bus, dev, 0, PCI0_HEADER_TYPE, &hd);
     44          pci_read_config_byte(bus, dev, 0, PCI_HEADER_TYPE, &hd);
    3245          hd = (hd & PCI_MULTI_FUNCTION ? PCI_MAX_FUNCTIONS : 1);
    3346          for (fun=0; fun<hd; fun++) {
     
    3750              if (PCI_MAX_DEVICES-1==dev && PCI_MAX_FUNCTIONS-1 == fun)
    3851                 break;
    39               (void)PCIx_read_config_dword(pciNum, bus,dev,fun,PCI0_VENDOR_ID,&d);
     52              (void)pci_read_config_dword(bus,dev,fun,PCI_VENDOR_ID,&d);
    4053              if (PCI_INVALID_VENDORDEVICEID == d)
    4154                 continue;
    42 #ifdef PCI_DEBUG
    43               printk("pci_find_device: found 0x%08x at %d/%d/%d\n",d,bus,dev,fun);
    44 #endif
    45               (void)PCIx_read_config_word(pciNum, bus,dev,fun,PCI0_VENDOR_ID,&s);
     55              if (BSP_pciDebug) {
     56                 printk("pci_find_device: found 0x%08x at %2d/%2d/%2d ",d,bus,dev,fun);
     57                 printk("(Physically: PCI%d  %2d/%2d/%2d)\n",
     58                     (bus>= BSP_MAX_PCI_BUS_ON_PCI0)? 1:0,
     59                     (bus>= BSP_MAX_PCI_BUS_ON_PCI0)? bus-BSP_MAX_PCI_BUS_ON_PCI0:bus,
     60                     dev, fun);
     61              }
     62
     63              (void)pci_read_config_word(bus,dev,fun,PCI_VENDOR_ID,&s);
    4664              if (vendorid != s)
    4765                 continue;
    48               (void)PCIx_read_config_word(pciNum, bus,dev,fun,PCI0_DEVICE_ID,&s);
     66              (void)pci_read_config_word(bus,dev,fun,PCI_DEVICE_ID,&s);
    4967              if (deviceid == s) {
    5068                 if (instance--) continue;
     
    5876}
    5977
    60 int pci_find_device( unsigned short vendorid, unsigned short deviceid,
    61                    int instance, int *pbus, int *pdev, int *pfun )
    62 {
    63   return(BSP_PCIxFindDevice(vendorid,deviceid,instance,0,pbus,pdev,pfun));
    64 }
    65 
    6678/* eof */
Note: See TracChangeset for help on using the changeset viewer.