Changeset 0943f48 in rtems


Ignore:
Timestamp:
Mar 14, 2005, 9:43:30 PM (16 years ago)
Author:
Joel Sherrill <joel.sherrill@…>
Branches:
4.10, 4.11, 4.8, 4.9, 5, master
Children:
fb77bc8
Parents:
48e329fb
Message:

2005-03-14 Joel Sherrill <joel@…>

  • pci/pci.c, pci/pci.h, pci/pcifinddevice.c: Continue PCI API unification. All use pci_find_device(). Also reformat to remove tabs.
Location:
c/src/lib/libbsp/powerpc/shared
Files:
4 edited

Legend:

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

    r48e329fb r0943f48  
     12005-03-14      Joel Sherrill <joel@OARcorp.com>
     2
     3        * pci/pci.c, pci/pci.h, pci/pcifinddevice.c: Continue PCI API
     4        unification. All use pci_find_device(). Also reformat to remove tabs.
     5
    162005-03-04      Joel Sherrill <joel@OARcorp.com>
    27
  • c/src/lib/libbsp/powerpc/shared/pci/pci.c

    r48e329fb r0943f48  
    2626/* allow for overriding these definitions */
    2727#ifndef PCI_CONFIG_ADDR
    28 #define PCI_CONFIG_ADDR                 0xcf8
     28#define PCI_CONFIG_ADDR      0xcf8
    2929#endif
    3030#ifndef PCI_CONFIG_DATA
    31 #define PCI_CONFIG_DATA                 0xcfc
     31#define PCI_CONFIG_DATA      0xcfc
    3232#endif
    3333
    34 #define PCI_INVALID_VENDORDEVICEID      0xffffffff
    35 #define PCI_MULTI_FUNCTION              0x80
     34#define PCI_INVALID_VENDORDEVICEID  0xffffffff
     35#define PCI_MULTI_FUNCTION    0x80
    3636
    3737/* define a shortcut */
    38 #define pci     BSP_pci_configuration
     38#define pci  BSP_pci_configuration
    3939
    4040/*
     
    4444
    4545static int
    46 indirect_pci_read_config_byte(unsigned char bus, unsigned char slot,
    47                               unsigned char function,
    48                               unsigned char offset, unsigned char *val) {
    49         out_be32((unsigned int*) pci.pci_config_addr,
    50                  0x80|(bus<<8)|(PCI_DEVFN(slot,function)<<16)|((offset&~3)<<24));
    51         *val = in_8(pci.pci_config_data + (offset&3));
    52         return PCIBIOS_SUCCESSFUL;
    53 }
    54 
    55 static int
    56 indirect_pci_read_config_word(unsigned char bus, unsigned char slot,
    57                               unsigned char function,
    58                               unsigned char offset, unsigned short *val) {
    59         *val = 0xffff;
    60         if (offset&1) return PCIBIOS_BAD_REGISTER_NUMBER;
    61         out_be32((unsigned int*) pci.pci_config_addr,
    62                  0x80|(bus<<8)|(PCI_DEVFN(slot,function)<<16)|((offset&~3)<<24));
    63         *val = in_le16((volatile unsigned short *)(pci.pci_config_data + (offset&3)));
    64         return PCIBIOS_SUCCESSFUL;
    65 }
    66 
    67 static int
    68 indirect_pci_read_config_dword(unsigned char bus, unsigned char slot,
    69                               unsigned char function,
    70                               unsigned char offset, unsigned int *val) {
    71         *val = 0xffffffff;
    72         if (offset&3) return PCIBIOS_BAD_REGISTER_NUMBER;
    73         out_be32((unsigned int*) pci.pci_config_addr,
    74                  0x80|(bus<<8)|(PCI_DEVFN(slot,function)<<16)|(offset<<24));
    75         *val = in_le32((volatile unsigned int *)pci.pci_config_data);
    76         return PCIBIOS_SUCCESSFUL;
    77 }
    78 
    79 static int
    80 indirect_pci_write_config_byte(unsigned char bus, unsigned char slot,
    81                                unsigned char function,
    82                                unsigned char offset, unsigned char val) {
    83         out_be32((unsigned int*) pci.pci_config_addr,
    84                  0x80|(bus<<8)|(PCI_DEVFN(slot,function)<<16)|((offset&~3)<<24));
    85         out_8(pci.pci_config_data + (offset&3), val);
    86         return PCIBIOS_SUCCESSFUL;
    87 }
    88 
    89 static int
    90 indirect_pci_write_config_word(unsigned char bus, unsigned char slot,
    91                                unsigned char function,
    92                                unsigned char offset, unsigned short val) {
    93         if (offset&1) return PCIBIOS_BAD_REGISTER_NUMBER;
    94         out_be32((unsigned int*) pci.pci_config_addr,
    95                  0x80|(bus<<8)|(PCI_DEVFN(slot,function)<<16)|((offset&~3)<<24));
    96         out_le16((volatile unsigned short *)(pci.pci_config_data + (offset&3)), val);
    97         return PCIBIOS_SUCCESSFUL;
    98 }
    99 
    100 static int
    101 indirect_pci_write_config_dword(unsigned char bus, unsigned char slot,
    102                                 unsigned char function,
    103                                 unsigned char offset, unsigned int val) {
    104         if (offset&3) return PCIBIOS_BAD_REGISTER_NUMBER;
    105         out_be32((unsigned int*) pci.pci_config_addr,
    106                  0x80|(bus<<8)|(PCI_DEVFN(slot,function)<<16)|(offset<<24));
    107         out_le32((volatile unsigned int *)pci.pci_config_data, val);
    108         return PCIBIOS_SUCCESSFUL;
     46indirect_pci_read_config_byte(
     47  unsigned char bus,
     48  unsigned char slot,
     49  unsigned char function,
     50  unsigned char offset,
     51  unsigned char *val
     52) {
     53  out_be32((unsigned int*) pci.pci_config_addr,
     54     0x80|(bus<<8)|(PCI_DEVFN(slot,function)<<16)|((offset&~3)<<24));
     55  *val = in_8(pci.pci_config_data + (offset&3));
     56  return PCIBIOS_SUCCESSFUL;
     57}
     58
     59static int
     60indirect_pci_read_config_word(
     61  unsigned char bus,
     62  unsigned char slot,
     63  unsigned char function,
     64  unsigned char offset,
     65  unsigned short *val
     66) {
     67  *val = 0xffff;
     68  if (offset&1)
     69    return PCIBIOS_BAD_REGISTER_NUMBER;
     70
     71  out_be32((unsigned int*) pci.pci_config_addr,
     72     0x80|(bus<<8)|(PCI_DEVFN(slot,function)<<16)|((offset&~3)<<24));
     73  *val = in_le16((volatile unsigned short *)(pci.pci_config_data + (offset&3)));
     74  return PCIBIOS_SUCCESSFUL;
     75}
     76
     77static int
     78indirect_pci_read_config_dword(
     79  unsigned char bus,
     80  unsigned char slot,
     81  unsigned char function,
     82  unsigned char offset,
     83  unsigned int *val
     84) {
     85  *val = 0xffffffff;
     86  if (offset&3)
     87    return PCIBIOS_BAD_REGISTER_NUMBER;
     88
     89  out_be32((unsigned int*) pci.pci_config_addr,
     90     0x80|(bus<<8)|(PCI_DEVFN(slot,function)<<16)|(offset<<24));
     91  *val = in_le32((volatile unsigned int *)pci.pci_config_data);
     92  return PCIBIOS_SUCCESSFUL;
     93}
     94
     95static int
     96indirect_pci_write_config_byte(
     97  unsigned char bus,
     98  unsigned char slot,
     99  unsigned char function,
     100  unsigned char offset,
     101  unsigned char val
     102) {
     103  out_be32((unsigned int*) pci.pci_config_addr,
     104     0x80|(bus<<8)|(PCI_DEVFN(slot,function)<<16)|((offset&~3)<<24));
     105  out_8(pci.pci_config_data + (offset&3), val);
     106  return PCIBIOS_SUCCESSFUL;
     107}
     108
     109static int
     110indirect_pci_write_config_word(
     111  unsigned char bus,
     112  unsigned char slot,
     113  unsigned char function,
     114  unsigned char offset,
     115  unsigned short val
     116) {
     117  if (offset&1)
     118    return PCIBIOS_BAD_REGISTER_NUMBER;
     119
     120  out_be32((unsigned int*) pci.pci_config_addr,
     121     0x80|(bus<<8)|(PCI_DEVFN(slot,function)<<16)|((offset&~3)<<24));
     122  out_le16((volatile unsigned short *)(pci.pci_config_data + (offset&3)), val);
     123  return PCIBIOS_SUCCESSFUL;
     124}
     125
     126static int
     127indirect_pci_write_config_dword(
     128  unsigned char bus,
     129  unsigned char slot,
     130  unsigned char function,
     131  unsigned char offset,
     132  unsigned int val
     133) {
     134  if (offset&3)
     135    return PCIBIOS_BAD_REGISTER_NUMBER;
     136  out_be32((unsigned int*) pci.pci_config_addr,
     137     0x80|(bus<<8)|(PCI_DEVFN(slot,function)<<16)|(offset<<24));
     138  out_le32((volatile unsigned int *)pci.pci_config_data, val);
     139  return PCIBIOS_SUCCESSFUL;
    109140}
    110141
    111142const pci_config_access_functions pci_indirect_functions = {
    112         indirect_pci_read_config_byte,
    113         indirect_pci_read_config_word,
    114         indirect_pci_read_config_dword,
    115         indirect_pci_write_config_byte,
    116         indirect_pci_write_config_word,
    117         indirect_pci_write_config_dword
     143  indirect_pci_read_config_byte,
     144  indirect_pci_read_config_word,
     145  indirect_pci_read_config_dword,
     146  indirect_pci_write_config_byte,
     147  indirect_pci_write_config_word,
     148  indirect_pci_write_config_dword
    118149};
    119150
    120 pci_config BSP_pci_configuration = {(volatile unsigned char*)PCI_CONFIG_ADDR,
    121                          (volatile unsigned char*)PCI_CONFIG_DATA,
    122                          &pci_indirect_functions};
    123 
    124 static int
    125 direct_pci_read_config_byte(unsigned char bus, unsigned char slot,
    126                             unsigned char function,
    127                             unsigned char offset, unsigned char *val) {
    128         if (bus != 0 || (1<<slot & 0xff8007fe)) {
    129                 *val=0xff;
    130                 return PCIBIOS_DEVICE_NOT_FOUND;
    131         }
    132         *val=in_8(pci.pci_config_data + ((1<<slot)&~1)
    133                   + (function<<8) + offset);
    134         return PCIBIOS_SUCCESSFUL;
    135 }
    136 
    137 static int
    138 direct_pci_read_config_word(unsigned char bus, unsigned char slot,
    139                             unsigned char function,
    140                             unsigned char offset, unsigned short *val) {
    141         *val = 0xffff;
    142         if (offset&1) return PCIBIOS_BAD_REGISTER_NUMBER;
    143         if (bus != 0 || (1<<slot & 0xff8007fe)) {
    144                 return PCIBIOS_DEVICE_NOT_FOUND;
    145         }
    146         *val=in_le16((volatile unsigned short *)
    147                      (pci.pci_config_data + ((1<<slot)&~1)
    148                       + (function<<8) + offset));
    149         return PCIBIOS_SUCCESSFUL;
    150 }
    151 
    152 static int
    153 direct_pci_read_config_dword(unsigned char bus, unsigned char slot,
    154                              unsigned char function,
    155                              unsigned char offset, unsigned int *val) {
    156         *val = 0xffffffff;
    157         if (offset&3) return PCIBIOS_BAD_REGISTER_NUMBER;
    158         if (bus != 0 || (1<<slot & 0xff8007fe)) {
    159                 return PCIBIOS_DEVICE_NOT_FOUND;
    160         }
    161         *val=in_le32((volatile unsigned int *)
    162                      (pci.pci_config_data + ((1<<slot)&~1)
    163                       + (function<<8) + offset));
    164         return PCIBIOS_SUCCESSFUL;
    165 }
    166 
    167 static int
    168 direct_pci_write_config_byte(unsigned char bus, unsigned char slot,
    169                              unsigned char function,
    170                              unsigned char offset, unsigned char val) {
    171         if (bus != 0 || (1<<slot & 0xff8007fe)) {
    172                 return PCIBIOS_DEVICE_NOT_FOUND;
    173         }
    174         out_8(pci.pci_config_data + ((1<<slot)&~1)
    175               + (function<<8) + offset,
    176               val);
    177         return PCIBIOS_SUCCESSFUL;
    178 }
    179 
    180 static int
    181 direct_pci_write_config_word(unsigned char bus, unsigned char slot,
    182                              unsigned char function,
    183                              unsigned char offset, unsigned short val) {
    184         if (offset&1) return PCIBIOS_BAD_REGISTER_NUMBER;
    185         if (bus != 0 || (1<<slot & 0xff8007fe)) {
    186                 return PCIBIOS_DEVICE_NOT_FOUND;
    187         }
    188         out_le16((volatile unsigned short *)
    189                  (pci.pci_config_data + ((1<<slot)&~1)
    190                   + (function<<8) + offset),
    191                  val);
    192         return PCIBIOS_SUCCESSFUL;
    193 }
    194 
    195 static int
    196 direct_pci_write_config_dword(unsigned char bus, unsigned char slot,
    197                               unsigned char function,
    198                               unsigned char offset, unsigned int val) {
    199         if (offset&3) return PCIBIOS_BAD_REGISTER_NUMBER;
    200         if (bus != 0 || (1<<slot & 0xff8007fe)) {
    201                 return PCIBIOS_DEVICE_NOT_FOUND;
    202         }
    203         out_le32((volatile unsigned int *)
    204                  (pci.pci_config_data + ((1<<slot)&~1)
    205                   + (function<<8) + offset),
    206                  val);
    207         return PCIBIOS_SUCCESSFUL;
     151pci_config BSP_pci_configuration = {
     152  (volatile unsigned char*)PCI_CONFIG_ADDR,
     153  (volatile unsigned char*)PCI_CONFIG_DATA,
     154  &pci_indirect_functions
     155};
     156
     157static int
     158direct_pci_read_config_byte(
     159  unsigned char bus,
     160  unsigned char slot,
     161  unsigned char function,
     162  unsigned char offset,
     163  unsigned char *val
     164) {
     165  if (bus != 0 || (1<<slot & 0xff8007fe)) {
     166    *val=0xff;
     167     return PCIBIOS_DEVICE_NOT_FOUND;
     168  }
     169  *val=in_8(pci.pci_config_data + ((1<<slot)&~1)
     170   + (function<<8) + offset);
     171  return PCIBIOS_SUCCESSFUL;
     172}
     173
     174static int
     175direct_pci_read_config_word(
     176  unsigned char bus,
     177  unsigned char slot,
     178  unsigned char function,
     179  unsigned char offset,
     180  unsigned short *val
     181) {
     182  *val = 0xffff;
     183  if (offset&1)
     184    return PCIBIOS_BAD_REGISTER_NUMBER;
     185  if (bus != 0 || (1<<slot & 0xff8007fe))
     186     return PCIBIOS_DEVICE_NOT_FOUND;
     187
     188  *val=in_le16((volatile unsigned short *)
     189      (pci.pci_config_data + ((1<<slot)&~1)
     190       + (function<<8) + offset));
     191  return PCIBIOS_SUCCESSFUL;
     192}
     193
     194static int
     195direct_pci_read_config_dword(
     196  unsigned char bus,
     197  unsigned char slot,
     198  unsigned char function,
     199  unsigned char offset,
     200  unsigned int *val
     201) {
     202  *val = 0xffffffff;
     203  if (offset&3)
     204    return PCIBIOS_BAD_REGISTER_NUMBER;
     205  if (bus != 0 || (1<<slot & 0xff8007fe))
     206     return PCIBIOS_DEVICE_NOT_FOUND;
     207
     208  *val=in_le32((volatile unsigned int *)
     209      (pci.pci_config_data + ((1<<slot)&~1)
     210       + (function<<8) + offset));
     211  return PCIBIOS_SUCCESSFUL;
     212}
     213
     214static int
     215direct_pci_write_config_byte(
     216  unsigned char bus,
     217  unsigned char slot,
     218  unsigned char function,
     219  unsigned char offset,
     220  unsigned char val
     221) {
     222  if (bus != 0 || (1<<slot & 0xff8007fe))
     223     return PCIBIOS_DEVICE_NOT_FOUND;
     224
     225  out_8(pci.pci_config_data + ((1<<slot)&~1)
     226     + (function<<8) + offset,
     227     val);
     228  return PCIBIOS_SUCCESSFUL;
     229}
     230
     231static int
     232direct_pci_write_config_word(
     233  unsigned char bus,
     234  unsigned char slot,
     235  unsigned char function,
     236  unsigned char offset,
     237  unsigned short val
     238) {
     239  if (offset&1)
     240    return PCIBIOS_BAD_REGISTER_NUMBER;
     241  if (bus != 0 || (1<<slot & 0xff8007fe))
     242     return PCIBIOS_DEVICE_NOT_FOUND;
     243
     244  out_le16((volatile unsigned short *)
     245     (pci.pci_config_data + ((1<<slot)&~1)
     246   + (function<<8) + offset),
     247     val);
     248  return PCIBIOS_SUCCESSFUL;
     249}
     250
     251static int
     252direct_pci_write_config_dword(
     253  unsigned char bus,
     254  unsigned char slot,
     255  unsigned char function,
     256  unsigned char offset,
     257  unsigned int val
     258) {
     259  if (offset&3)
     260    return PCIBIOS_BAD_REGISTER_NUMBER;
     261  if (bus != 0 || (1<<slot & 0xff8007fe))
     262     return PCIBIOS_DEVICE_NOT_FOUND;
     263
     264  out_le32((volatile unsigned int *)
     265     (pci.pci_config_data + ((1<<slot)&~1)
     266   + (function<<8) + offset),
     267     val);
     268  return PCIBIOS_SUCCESSFUL;
    208269}
    209270
    210271const pci_config_access_functions pci_direct_functions = {
    211         direct_pci_read_config_byte,
    212         direct_pci_read_config_word,
    213         direct_pci_read_config_dword,
    214         direct_pci_write_config_byte,
    215         direct_pci_write_config_word,
    216         direct_pci_write_config_dword
     272  direct_pci_read_config_byte,
     273  direct_pci_read_config_word,
     274  direct_pci_read_config_dword,
     275  direct_pci_write_config_byte,
     276  direct_pci_write_config_word,
     277  direct_pci_write_config_dword
    217278};
    218279
    219280#define PRINT_MSG() \
    220              printk("pci : Device %d:%02x routed to interrupt_line %d\n", pbus, pslot, int_name )
     281  printk("pci : Device %d:%02x routed to interrupt_line %d\n", \
     282    pbus, pslot, int_name )
    221283
    222284/*
     
    230292  int int_pin,
    231293  int int_name
    232 )
    233 {
    234    int j, k;
    235    int _nopin= -1, _noname= -1;
    236 
    237    for(j=0; row->pin_route[j].pin > -1; j++)
    238    {
    239       if( row->pin_route[j].pin == int_pin )
    240       {
    241          _nopin = 0;
    242 
    243          for(k=0; k<4 && row->pin_route[j].int_name[k] > -1; k++ )
    244          {
    245             if( row->pin_route[j].int_name[k] == int_name ){ _noname=0; break; }
    246          }
    247          break;
    248       }
     294) {
     295  int j, k;
     296  int _nopin= -1, _noname= -1;
     297
     298  for (j=0; row->pin_route[j].pin > -1; j++) {
     299    if ( row->pin_route[j].pin == int_pin ) {
     300   _nopin = 0;
     301
     302   for (k=0; k<4 && row->pin_route[j].int_name[k] > -1; k++ ) {
     303     if ( row->pin_route[j].int_name[k] == int_name ) {
     304       _noname=0; break;
     305     }
    249306   }
    250 
    251    if( _nopin  )
    252    {
    253       printk("pci : Device %d:%02x supplied a bogus interrupt_pin %d\n", pbus, pslot, int_pin );
    254       return -1;
    255    }
    256    else
    257    {
    258       if( _noname )
    259          printk("pci : Device %d:%02x supplied a suspicious interrupt_line %d, using it anyway\n", pbus, pslot, int_name );
    260    }
    261    return 0;
     307   break;
     308    }
     309  }
     310
     311  if ( _nopin  ) {
     312    printk("pci : Device %d:%02x supplied a bogus interrupt_pin %d\n",
     313   pbus, pslot, int_pin );
     314    return -1;
     315  } else {
     316    if ( _noname )
     317   printk("pci : Device %d:%02x supplied a suspicious interrupt_line %d,"
     318          " using it anyway\n", pbus, pslot, int_name );
     319  }
     320  return 0;
    262321}
    263322
    264323struct pcibridge
    265324{
    266       int bus,slot;
     325  int bus;
     326  int slot;
    267327};
    268328
    269329static int FindPCIbridge( int mybus, struct pcibridge *pb )
    270330{
    271    int          pbus, pslot;
    272    uint8_t      bussec, buspri;
    273    uint16_t     devid, vendorid, dclass;
    274 
    275    for(pbus=0; pbus< BusCountPCI(); pbus++)
    276    {
    277       for(pslot=0; pslot< PCI_MAX_DEVICES; pslot++)
    278       {
    279          pci_read_config_word(pbus, pslot, 0, PCI_DEVICE_ID, &devid);
    280          if( devid == 0xffff ) continue;
    281 
    282          pci_read_config_word(pbus, pslot, 0, PCI_DEVICE_ID, &vendorid);
    283          if( vendorid == 0xffff ) continue;
    284 
    285          pci_read_config_word(pbus, pslot, 0, PCI_CLASS_DEVICE, &dclass);
    286 
    287          if( dclass == PCI_CLASS_BRIDGE_PCI )
    288          {
    289             pci_read_config_byte(pbus, pslot, 0, PCI_PRIMARY_BUS,    &buspri);
    290             pci_read_config_byte(pbus, pslot, 0, PCI_SECONDARY_BUS,  &bussec);
     331  int          pbus, pslot;
     332  uint8_t      bussec, buspri;
     333  uint16_t     devid, vendorid, dclass;
     334
     335  for(pbus=0; pbus< BusCountPCI(); pbus++) {
     336    for(pslot=0; pslot< PCI_MAX_DEVICES; pslot++) {
     337      pci_read_config_word(pbus, pslot, 0, PCI_DEVICE_ID, &devid);
     338      if ( devid == 0xffff ) continue;
     339
     340      pci_read_config_word(pbus, pslot, 0, PCI_DEVICE_ID, &vendorid);
     341      if ( vendorid == 0xffff ) continue;
     342
     343      pci_read_config_word(pbus, pslot, 0, PCI_CLASS_DEVICE, &dclass);
     344
     345      if ( dclass == PCI_CLASS_BRIDGE_PCI ) {
     346        pci_read_config_byte(pbus, pslot, 0, PCI_PRIMARY_BUS,    &buspri);
     347        pci_read_config_byte(pbus, pslot, 0, PCI_SECONDARY_BUS,  &bussec);
    291348
    292349#if 0
    293             printk("pci : Found bridge at %d:%d, mybus %d, pribus %d, secbus %d  ", pbus, pslot, mybus, buspri, bussec );
     350         printk("pci : Found bridge at %d:%d, mybus %d, pribus %d, secbus %d ",
     351                 pbus, pslot, mybus, buspri, bussec );
    294352#endif
    295             if( bussec == mybus )
    296             {
     353         if ( bussec == mybus ) {
    297354#if 0
    298                printk("match\n");
     355           printk("match\n");
    299356#endif
    300                /* found our nearest bridge going towards the root */
    301                pb->bus = pbus;
    302                pb->slot = pslot;
    303 
    304                return 0;
    305             }
     357           /* found our nearest bridge going towards the root */
     358           pb->bus = pbus;
     359           pb->slot = pslot;
     360
     361           return 0;
     362        }
    306363#if 0
    307             printk("no match\n");
     364         printk("no match\n");
    308365#endif
    309          }
    310 
    311366      }
     367
     368     }
    312369   }
    313370   return -1;
     
    316373void FixupPCI( const struct _int_map *bspmap, int (*swizzler)(int,int) )
    317374{
    318    unsigned char        cvalue;
    319    uint16_t             devid;
    320    int                  ismatch, i, j, pbus, pslot, int_pin, int_name;
    321 
    322    /*
    323    ** If the device has a non-zero INTERRUPT_PIN, assign a bsp-specific
    324    ** INTERRUPT_NAME if one isn't already in place.  Then, drivers can
    325    ** trivially use INTERRUPT_NAME to hook up with devices.
     375  unsigned char        cvalue;
     376  uint16_t             devid;
     377  int                  ismatch, i, j, pbus, pslot, int_pin, int_name;
     378
     379  /*
     380   * If the device has a non-zero INTERRUPT_PIN, assign a bsp-specific
     381   * INTERRUPT_NAME if one isn't already in place.  Then, drivers can
     382   * trivially use INTERRUPT_NAME to hook up with devices.
    326383   */
    327384
    328    for(pbus=0; pbus< BusCountPCI(); pbus++)
    329    {
    330       for(pslot=0; pslot< PCI_MAX_DEVICES; pslot++)
     385  for (pbus=0; pbus< BusCountPCI(); pbus++) {
     386    for (pslot=0; pslot< PCI_MAX_DEVICES; pslot++) {
     387      pci_read_config_word(pbus, pslot, 0, PCI_DEVICE_ID, &devid);
     388      if ( devid == 0xffff ) continue;
     389
     390      /* got a device */
     391
     392      pci_read_config_byte( pbus, pslot, 0, PCI_INTERRUPT_PIN, &cvalue);
     393      int_pin = cvalue;
     394
     395      pci_read_config_byte( pbus, pslot, 0, PCI_INTERRUPT_LINE, &cvalue);
     396      int_name = cvalue;
     397
     398      /* printk("pci : device %d:%02x devid %04x, intpin %d, intline  %d\n",
     399         pbus, pslot, devid, int_pin, int_name ); */
     400
     401#if 0
    331402      {
    332          pci_read_config_word(pbus, pslot, 0, PCI_DEVICE_ID, &devid);
    333          if( devid == 0xffff ) continue;
    334 
    335          /* got a device */
    336 
    337          pci_read_config_byte( pbus, pslot, 0, PCI_INTERRUPT_PIN, &cvalue);
    338          int_pin = cvalue;
    339 
    340          pci_read_config_byte( pbus, pslot, 0, PCI_INTERRUPT_LINE, &cvalue);
    341          int_name = cvalue;
    342 
    343 /* printk("pci : device %d:%02x devid %04x, intpin %d, intline  %d\n", pbus, pslot, devid, int_pin, int_name ); */
    344 
    345 #if 0
    346          {
    347             unsigned short cmd,stat;
    348             unsigned char  lat, seclat, csize;
    349 
    350             pci_read_config_word(pbus,pslot,0,PCI_COMMAND, &cmd );
    351             pci_read_config_word(pbus,pslot,0,PCI_STATUS, &stat );
    352             pci_read_config_byte(pbus,pslot,0,PCI_LATENCY_TIMER, &lat );
    353             pci_read_config_byte(pbus,pslot,0,PCI_SEC_LATENCY_TIMER, &seclat );
    354             pci_read_config_byte(pbus,pslot,0,PCI_CACHE_LINE_SIZE, &csize );
    355            
    356 
    357             printk("pci : device %d:%02x  cmd %04X, stat %04X, latency %d, sec_latency %d, clsize %d\n", pbus, pslot,
    358                    cmd,
    359                    stat,
    360                    lat,
    361                    seclat,
    362                    csize);
    363          }
     403         unsigned short cmd,stat;
     404         unsigned char  lat, seclat, csize;
     405
     406         pci_read_config_word(pbus,pslot,0,PCI_COMMAND, &cmd );
     407         pci_read_config_word(pbus,pslot,0,PCI_STATUS, &stat );
     408         pci_read_config_byte(pbus,pslot,0,PCI_LATENCY_TIMER, &lat );
     409         pci_read_config_byte(pbus,pslot,0,PCI_SEC_LATENCY_TIMER, &seclat );
     410         pci_read_config_byte(pbus,pslot,0,PCI_CACHE_LINE_SIZE, &csize );
     411         
     412
     413         printk("pci : device %d:%02x  cmd %04X, stat %04X, latency %d, "
     414                " sec_latency %d, clsize %d\n", pbus, pslot, cmd, stat,
     415                lat, seclat, csize);
     416      }
    364417#endif
    365418
    366          if( int_pin > 0 )
    367          {
    368             ismatch = 0;
    369 
    370             /*
    371             ** first run thru the bspmap table and see if we have an explicit configuration
    372             */
    373             for(i=0; bspmap[i].bus > -1; i++)
    374             {
    375                if( bspmap[i].bus == pbus && bspmap[i].slot == pslot )
    376                {
    377                   ismatch = -1;
    378                   /* we have a record in the table that gives specific
    379                    * pins and interrupts for devices in this slot */
    380                   if( int_name == 255 )
    381                   {
    382                      /* find the vector associated with whatever pin the device gives us */
    383                      for( int_name=-1, j=0; bspmap[i].pin_route[j].pin > -1; j++ )
    384                      {
    385                         if( bspmap[i].pin_route[j].pin == int_pin )
    386                         {
    387                            int_name = bspmap[i].pin_route[j].int_name[0];
    388                            break;
    389                         }
    390                      }
    391                      if( int_name == -1 )
    392                      {
    393                         printk("pci : Unable to resolve device %d:%d w/ swizzled int pin %i to an interrupt_line.\n", pbus, pslot, int_pin );
    394                      }
    395                      else
    396                      {
    397                         PRINT_MSG();
    398                         pci_write_config_byte(pbus,pslot,0,PCI_INTERRUPT_LINE,(cvalue= int_name, cvalue));
    399                      }
     419      if ( int_pin > 0 ) {
     420        ismatch = 0;
     421
     422        /*
     423         * first run thru the bspmap table and see if we have an
     424         * explicit configuration
     425         */
     426        for (i=0; bspmap[i].bus > -1; i++) {
     427          if ( bspmap[i].bus == pbus && bspmap[i].slot == pslot ) {
     428            ismatch = -1;
     429            /* we have a record in the table that gives specific
     430             * pins and interrupts for devices in this slot */
     431            if ( int_name == 255 ) {
     432              /* find the vector associated with whatever pin the
     433               * device gives us
     434               */
     435              for ( int_name=-1, j=0; bspmap[i].pin_route[j].pin > -1; j++ ) {
     436                if ( bspmap[i].pin_route[j].pin == int_pin ) {
     437                  int_name = bspmap[i].pin_route[j].int_name[0];
     438                  break;
     439                }
     440              }
     441              if ( int_name == -1 ) {
     442                printk("pci : Unable to resolve device %d:%d w/ swizzled int "
     443                       "pin %i to an interrupt_line.\n", pbus, pslot, int_pin );
     444              } else {
     445                PRINT_MSG();
     446                pci_write_config_byte( pbus,pslot,0,
     447                    PCI_INTERRUPT_LINE,(cvalue= int_name, cvalue));
     448              }
     449            } else {
     450              test_intname( &bspmap[i],pbus,pslot,int_pin,int_name);
     451            }
     452            break;
     453          }
     454        }
     455
     456        if ( !ismatch ) {
     457          /*
     458           * no match, which means we're on a bus someplace.  Work
     459           * backwards from it to one of our defined busses,
     460           * swizzling thru each bridge on the way.
     461           */
     462
     463          /* keep pbus, pslot pointed to the device being
     464           * configured while we track down the bridges using
     465           * tbus,tslot.  We keep searching the routing table because
     466           * we may end up finding our bridge in it
     467           */
     468
     469          int tbus= pbus, tslot= pslot;
     470
     471          for (;;) {
     472            for (i=0; bspmap[i].bus > -1; i++) {
     473              if ( bspmap[i].bus == tbus &&
     474                   (bspmap[i].slot == tslot || bspmap[i].slot == -1) ) {
     475                ismatch = -1;
     476                /* found a record for this bus, so swizzle the
     477                 * int_pin which we then use to find the
     478                 * interrupt_name.
     479                 */
     480
     481                if ( int_name == 255 ) {
     482                  /*
     483                   * FIXME.  I can't believe this little hack
     484                   * is right.  It does not yield an error in
     485                   * convienently simple situations.
     486                   */
     487                  if ( tbus ) int_pin = (*swizzler)(tslot,int_pin);
     488
     489                  /*
     490                   * int_pin points to the interrupt channel
     491                   * this card ends up delivering interrupts
     492                   * on.  Find the int_name servicing it.
     493                   */
     494                  for (int_name=-1, j=0; bspmap[i].pin_route[j].pin > -1; j++){
     495                    if ( bspmap[i].pin_route[j].pin == int_pin ) {
     496                      int_name = bspmap[i].pin_route[j].int_name[0];
     497                      break;
     498                    }
    400499                  }
    401                   else
    402                   {
    403                      test_intname( &bspmap[i],pbus,pslot,int_pin,int_name);
     500
     501                  if ( int_name == -1 ) {
     502                    printk("pci : Unable to resolve device %d:%d w/ swizzled "
     503                           "int pin %i to an interrupt_line.\n",
     504                           pbus, pslot, int_pin );
     505                  } else {
     506                    PRINT_MSG();
     507                    pci_write_config_byte(pbus,pslot,0,
     508                      PCI_INTERRUPT_LINE,(cvalue=int_name, cvalue));
    404509                  }
    405                   break;
    406                }
     510                } else {
     511                  test_intname(&bspmap[i],pbus,pslot,int_pin,int_name);
     512                }
     513                goto donesearch;
     514              }
    407515            }
    408516
    409             if( !ismatch )
    410             {
    411                /*
    412                ** no match, which means we're on a bus someplace.  Work
    413                ** backwards from it to one of our defined busses,
    414                ** swizzling thru each bridge on the way.
     517            if ( !ismatch ) {
     518              struct pcibridge   pb;
     519
     520              /*
     521               * Haven't found our bus in the int map, so work
     522               * upwards thru the bridges till we find it.
    415523               */
    416524
    417                /* keep pbus, pslot pointed to the device being
    418                configured while we track down the bridges using
    419                tbus,tslot.  We keep searching the routing table because
    420                we may end up finding our bridge in it */
    421 
    422                int tbus= pbus, tslot= pslot;
    423 
    424                for(;;)
    425                {
    426 
    427                   for(i=0; bspmap[i].bus > -1; i++)
    428                   {
    429                      if( bspmap[i].bus == tbus && (bspmap[i].slot == tslot || bspmap[i].slot == -1) )
    430                      {
    431                         ismatch = -1;
    432                         /* found a record for this bus, so swizzle the
    433                          * int_pin which we then use to find the
    434                          * interrupt_name.
    435                          */
    436 
    437                         if( int_name == 255 )
    438                         {
    439                            /*
    440                            ** FIXME.  I can't believe this little hack
    441                            ** is right.  It does not yield an error in
    442                            ** convienently simple situations.
    443                            */
    444                            if( tbus ) int_pin = (*swizzler)(tslot,int_pin);
    445 
    446                            /*
    447                            ** int_pin points to the interrupt channel
    448                            ** this card ends up delivering interrupts
    449                            ** on.  Find the int_name servicing it.
    450                            */
    451                            for( int_name=-1, j=0; bspmap[i].pin_route[j].pin > -1; j++ )
    452                            {
    453                               if( bspmap[i].pin_route[j].pin == int_pin )
    454                               {
    455                                  int_name = bspmap[i].pin_route[j].int_name[0];
    456                                  break;
    457                               }
    458                            }
    459                            if( int_name == -1 )
    460                            {
    461                               printk("pci : Unable to resolve device %d:%d w/ swizzled int pin %i to an interrupt_line.\n", pbus, pslot, int_pin );
    462                            }
    463                            else
    464                            {
    465                               PRINT_MSG();
    466                               pci_write_config_byte(pbus,pslot,0,PCI_INTERRUPT_LINE,(cvalue= int_name, cvalue));
    467                            }
    468                         }
    469                         else
    470                         {
    471                            test_intname(&bspmap[i],pbus,pslot,int_pin,int_name);
    472                         }
    473                         goto donesearch;
    474                      }
    475                   }
    476 
    477                   if( !ismatch )
    478                   {
    479                      struct pcibridge   pb;
    480 
    481                      /*
    482                      ** Haven't found our bus in the int map, so work
    483                      ** upwards thru the bridges till we find it.
    484                      */
    485 
    486                      if( FindPCIbridge( tbus, &pb )== 0 )
    487                      {
    488                         int_pin = (*swizzler)(tslot,int_pin);
    489 
    490                         /* our next bridge up is on pb.bus, pb.slot- now
    491                         ** instead of pointing to the device we're
    492                         ** trying to configure, we move from bridge to
    493                         ** bridge.
    494                         */
    495 
    496                         tbus = pb.bus;
    497                         tslot = pb.slot;
    498                      }
    499                      else
    500                      {
    501                         printk("pci : No bridge from bus %i towards root found\n", tbus );
    502                         goto donesearch;
    503                      }
    504 
    505                   }
    506 
    507                }
     525              if ( FindPCIbridge( tbus, &pb )== 0 ) {
     526                int_pin = (*swizzler)(tslot,int_pin);
     527
     528                /* our next bridge up is on pb.bus, pb.slot- now
     529                 * instead of pointing to the device we're
     530                 * trying to configure, we move from bridge to
     531                 * bridge.
     532                 */
     533
     534                tbus = pb.bus;
     535                tslot = pb.slot;
     536              } else {
     537                printk("pci : No bridge from bus %i towards root found\n",
     538                       tbus );
     539                goto donesearch;
     540              }
    508541            }
    509            donesearch:
    510 
    511             if( !ismatch && int_pin != 0 && int_name == 255 )
    512             {
    513                printk("pci : Unable to match device %d:%d with an int routing table entry\n", pbus, pslot  );
    514             }
    515 
    516          }
     542          }
     543        }
     544        donesearch:
     545
     546        if ( !ismatch && int_pin != 0 && int_name == 255 ) {
     547            printk("pci : Unable to match device %d:%d with an int "
     548                   "routing table entry\n", pbus, pslot  );
     549        }
    517550      }
     551     }
    518552   }
    519553}
     
    522556 * This routine determines the maximum bus number in the system
    523557 */
    524 void pci_initialize()
     558int pci_initialize()
    525559{
    526560  extern void detect_host_bridge();
     
    535569   * Scan PCI bus 0 looking for PCI-PCI bridges
    536570   */
    537   for(ucSlotNumber=0;ucSlotNumber<PCI_MAX_DEVICES;ucSlotNumber++) {
    538     (void)pci_read_config_dword(0,
    539                                 ucSlotNumber,
    540                                 0,
    541                                 PCI_VENDOR_ID,
    542                                 &ulDeviceID);
    543     if(ulDeviceID==PCI_INVALID_VENDORDEVICEID) {
    544       /*
    545        * This slot is empty
    546        */
     571  for (ucSlotNumber=0;ucSlotNumber<PCI_MAX_DEVICES;ucSlotNumber++) {
     572    pci_read_config_dword(0, ucSlotNumber, 0, PCI_VENDOR_ID, &ulDeviceID);
     573    if (ulDeviceID==PCI_INVALID_VENDORDEVICEID) {
     574      /* This slot is empty */
    547575      continue;
    548576    }
    549     (void)pci_read_config_byte(0,
    550                                ucSlotNumber,
    551                                0,
    552                                PCI_HEADER_TYPE,
    553                                &ucHeader);
    554     if(ucHeader&PCI_MULTI_FUNCTION)     {
     577    pci_read_config_byte(0, ucSlotNumber, 0, PCI_HEADER_TYPE, &ucHeader);
     578    if (ucHeader&PCI_MULTI_FUNCTION)  {
    555579      ucNumFuncs=PCI_MAX_FUNCTIONS;
    556     }
    557     else {
     580    } else {
    558581      ucNumFuncs=1;
    559582    }
    560     for(ucFnNumber=0;ucFnNumber<ucNumFuncs;ucFnNumber++) {
    561       (void)pci_read_config_dword(0,
    562                                   ucSlotNumber,
    563                                   ucFnNumber,
    564                                   PCI_VENDOR_ID,
    565                                   &ulDeviceID);
    566       if(ulDeviceID==PCI_INVALID_VENDORDEVICEID) {
    567                                 /*
    568                                  * This slot/function is empty
    569                                  */
    570         continue;
     583    for (ucFnNumber=0;ucFnNumber<ucNumFuncs;ucFnNumber++) {
     584      pci_read_config_dword(0, ucSlotNumber, ucFnNumber,
     585                            PCI_VENDOR_ID, &ulDeviceID);
     586      if (ulDeviceID==PCI_INVALID_VENDORDEVICEID) {
     587        /* This slot/function is empty */
     588        continue;
    571589      }
    572590
    573       /*
    574        * This slot/function has a device fitted.
    575        */
    576       (void)pci_read_config_dword(0,
    577                                   ucSlotNumber,
    578                                   ucFnNumber,
    579                                   PCI_CLASS_REVISION,
    580                                   &ulClass);
     591      /* This slot/function has a device fitted. */
     592      pci_read_config_dword(0, ucSlotNumber, ucFnNumber,
     593                            PCI_CLASS_REVISION, &ulClass);
    581594      ulClass >>= 16;
    582595      if (ulClass == PCI_CLASS_BRIDGE_PCI) {
    583                                 /*
    584                                  * We have found a PCI-PCI bridge
    585                                  */
    586         (void)pci_read_config_byte(0,
    587                                    ucSlotNumber,
    588                                    ucFnNumber,
    589                                    PCI_SUBORDINATE_BUS,
    590                                    &ucMaxSubordinate);
    591         if(ucMaxSubordinate>ucMaxPCIBus) {
    592           ucMaxPCIBus=ucMaxSubordinate;
    593         }
    594       }
    595     }
    596   }
     596        /* We have found a PCI-PCI bridge */
     597        pci_read_config_byte(0, ucSlotNumber, ucFnNumber,
     598                     PCI_SUBORDINATE_BUS, &ucMaxSubordinate);
     599       if (ucMaxSubordinate>ucMaxPCIBus) {
     600         ucMaxPCIBus=ucMaxSubordinate;
     601       }
     602     }
     603   }
     604 }
     605 return PCIB_ERR_SUCCESS;
    597606}
    598607
     
    602611unsigned char BusCountPCI()
    603612{
    604   return(ucMaxPCIBus+1);
    605 }
     613  return (ucMaxPCIBus+1);
     614}
  • c/src/lib/libbsp/powerpc/shared/pci/pci.h

    r48e329fb r0943f48  
    3333void FixupPCI( const struct _int_map *, int (*swizzler)(int,int) );
    3434
    35 /* scan for a specific device */
    36 /* find a particular PCI device
    37  * (currently, only bus0 is scanned for device/fun0)
    38  *
    39  * RETURNS: zero on success, bus/dev/fun in *pbus / *pdev / *pfun
    40  */
    41 int
    42 BSP_pciFindDevice(unsigned short vendorid, unsigned short deviceid,
    43                 int instance, int *pbus, int *pdev, int *pfun);
    44 
    4535#endif /* BSP_POWERPC_PCI_H */
  • c/src/lib/libbsp/powerpc/shared/pci/pcifinddevice.c

    r48e329fb r0943f48  
    88 */
    99
    10 #define PCI_INVALID_VENDORDEVICEID      0xffffffff
    11 #define PCI_MULTI_FUNCTION                      0x80
     10#define PCI_INVALID_VENDORDEVICEID  0xffffffff
     11#define PCI_MULTI_FUNCTION      0x80
    1212
    1313#include <bsp/pci.h>
     
    1515
    1616int
    17 pci_find_by_devid( unsigned short vendorid, unsigned short deviceid,
    18                    int instance, int *pbus, int *pdev, int *pfun )
    19 {
     17pci_find_device(
     18  unsigned short vendorid,
     19  unsigned short deviceid,
     20  int instance,
     21  int *pbus,
     22  int *pdev,
     23  int *pfun
     24) {
    2025   unsigned int d;
    2126   unsigned short s;
    2227   unsigned char bus,dev,fun,hd;
    2328
    24         for (bus=0; bus<BusCountPCI(); bus++) {
    25       for (dev=0; dev<PCI_MAX_DEVICES; dev++) {
     29   for (bus=0; bus<BusCountPCI(); bus++) {
     30     for (dev=0; dev<PCI_MAX_DEVICES; dev++) {
    2631
    27                 pci_read_config_byte(bus,dev,0, PCI_HEADER_TYPE, &hd);
    28                 hd = (hd & PCI_MULTI_FUNCTION ? PCI_MAX_FUNCTIONS : 1);
     32       pci_read_config_byte(bus,dev,0, PCI_HEADER_TYPE, &hd);
     33       hd = (hd & PCI_MULTI_FUNCTION ? PCI_MAX_FUNCTIONS : 1);
    2934
    30                 for (fun=0; fun<hd; fun++) {
    31                         /*
    32                         * The last devfn id/slot is special; must skip it
    33                         */
    34                         if (PCI_MAX_DEVICES-1==dev && PCI_MAX_FUNCTIONS-1 == fun)
    35                                 break;
    36                         (void)pci_read_config_dword(bus,dev,fun,PCI_VENDOR_ID,&d);
    37                         if (PCI_INVALID_VENDORDEVICEID == d)
    38                                 continue;
     35       for (fun=0; fun<hd; fun++) {
     36         /*
     37          * The last devfn id/slot is special; must skip it
     38          */
     39        if (PCI_MAX_DEVICES-1==dev && PCI_MAX_FUNCTIONS-1 == fun)
     40          break;
     41        (void)pci_read_config_dword(bus,dev,fun,PCI_VENDOR_ID,&d);
     42        if (PCI_INVALID_VENDORDEVICEID == d)
     43          continue;
    3944#ifdef PCI_DEBUG
    40                         printk("pci_find_by_devid: found 0x%08x at %d/%d/%d\n",d,bus,dev,fun);
     45        printk("pci_find_by_devid: found 0x%08x at %d/%d/%d\n",d,bus,dev,fun);
    4146#endif
    42                         (void) pci_read_config_word(bus,dev,fun,PCI_VENDOR_ID,&s);
    43                         if (vendorid != s)
    44                                 continue;
    45                         (void) pci_read_config_word(bus,dev,fun,PCI_DEVICE_ID,&s);
    46                         if (deviceid == s) {
    47                                 if (instance--) continue;
    48                                 *pbus=bus; *pdev=dev; *pfun=fun;
    49                                 return 0;
    50                         }
    51                 }
     47        (void) pci_read_config_word(bus,dev,fun,PCI_VENDOR_ID,&s);
     48        if (vendorid != s)
     49          continue;
     50        (void) pci_read_config_word(bus,dev,fun,PCI_DEVICE_ID,&s);
     51        if (deviceid == s) {
     52          if (instance--) continue;
     53          *pbus=bus; *pdev=dev; *pfun=fun;
     54          return 0;
     55        }
    5256      }
    53         }
    54     return -1;
     57    }
     58  }
     59  return -1;
    5560}
    56 
    57 /* eof */
Note: See TracChangeset for help on using the changeset viewer.