Read number of PCI buses returned by BIOS so that we can scan more
[people/lynusvaz/gpxe.git] / src / arch / i386 / core / pci_io.c
1 /*
2 ** Support for NE2000 PCI clones added David Monro June 1997
3 ** Generalised to other NICs by Ken Yap July 1997
4 **
5 ** Most of this is taken from:
6 **
7 ** /usr/src/linux/drivers/pci/pci.c
8 ** /usr/src/linux/include/linux/pci.h
9 ** /usr/src/linux/arch/i386/bios32.c
10 ** /usr/src/linux/include/linux/bios32.h
11 ** /usr/src/linux/drivers/net/ne.c
12 */
13 #include "etherboot.h"
14 #include "init.h"
15 #include "pci.h"
16 #include "pci_io.h"
17 #ifdef KEEP_IT_REAL
18 #include "realmode.h"
19 #endif
20
21 /* Macros for direct PCI access */
22 #define CONFIG_ADDRESS  0xcf8
23 #define CONFIG_DATA     0xcfc
24 #define CONFIG_CMD( pci, where ) \
25         ( 0x80000000 | (pci->busdevfn << 8) | (where & ~3) )
26
27 /* Signatures for PCI BIOS */
28 #define BIOS_SIG(a,b,c,d)       ( ( a<<0 ) + ( b<<8 ) + ( c<<16 ) + ( d<<24 ) )
29 #define PRINT_BIOS_SIG(x)       ( (x) & 0xff ), ( ( (x)>>8 ) & 0xff ), \
30                                 ( ( (x)>>16 ) & 0xff ),( ( (x)>>24 ) & 0xff )
31 #define BIOS32_SIGNATURE        BIOS_SIG ( '_', '3', '2', '_' )
32 #define PCI_SIGNATURE           BIOS_SIG ( 'P', 'C', 'I', ' ' )
33 #define PCI_SERVICE             BIOS_SIG ( '$', 'P', 'C', 'I' )
34
35 /* BIOS32 structure as found in PCI BIOS ROM */
36 struct bios32 {
37         unsigned long signature;        /* _32_ */
38         unsigned long entry;            /* 32 bit physical address */
39         unsigned char revision;         /* Revision level, 0 */
40         unsigned char length;           /* Length in paragraphs */
41         unsigned char checksum;         /* Should byte sum to zero */
42         unsigned char reserved[5];      /* Must be zero */
43 };
44
45 /* Values returned by BIOS32 service directory */
46 #define BIOS32_SERVICE_PRESENT          0x00
47 #define BIOS32_SERVICE_NOT_PRESENT      0x80
48 #define CF ( 1 << 0 )
49
50 /* PCI BIOS entry point */
51 #ifndef KEEP_IT_REAL
52 static unsigned long pcibios32_entry;
53 #endif
54 static int have_pcibios;
55
56 /* Macro for calling a 32-bit entry point with flat physical
57  * addresses.  Use in a statement such as
58  * __asm__ ( FLAT_FAR_CALL_ESI,
59  *           : "=S" ( discard, or real output ), <other output registers>
60  *           : "S" ( entry_point ), <other input registers> );
61  * "=S" *must* be specified as an output, otherwise the compiler will
62  * assume that it remains unaltered.
63  */
64 #define FLAT_FAR_CALL_ESI "call _virt_to_phys\n\t" \
65                           "pushl %%cs\n\t" \
66                           "call *%%esi\n\t" \
67                           "cli\n\t" \
68                           "cld\n\t" \
69                           "call _phys_to_virt\n\t"
70
71 /*
72  * Functions for accessing PCI configuration space directly with type
73  * 1 accesses.
74  *
75  */
76
77 static inline int pcidirect_read_config_byte ( struct pci_device *pci,
78                                                unsigned int where,
79                                                uint8_t *value ) {
80     outl ( CONFIG_CMD ( pci, where ), CONFIG_ADDRESS );
81     *value = inb ( CONFIG_DATA + ( where & 3 ) );
82     return 0;
83 }
84
85 static inline int pcidirect_read_config_word ( struct pci_device *pci,
86                                                unsigned int where,
87                                                uint16_t *value ) {
88     outl ( CONFIG_CMD ( pci, where ), CONFIG_ADDRESS );
89     *value = inw ( CONFIG_DATA + ( where & 2 ) );
90     return 0;
91 }
92
93 static inline int pcidirect_read_config_dword ( struct pci_device *pci,
94                                                 unsigned int where,
95                                                 uint32_t *value ) {
96     outl ( CONFIG_CMD ( pci, where ), CONFIG_ADDRESS );
97     *value = inl ( CONFIG_DATA );
98     return 0;
99 }
100
101 static inline int pcidirect_write_config_byte ( struct pci_device *pci,
102                                                 unsigned int where,
103                                                 uint8_t value ) {
104     outl ( CONFIG_CMD ( pci, where ), CONFIG_ADDRESS );
105     outb ( value, CONFIG_DATA + ( where & 3 ) );
106     return 0;
107 }
108
109 static inline int pcidirect_write_config_word ( struct pci_device *pci,
110                                                 unsigned int where,
111                                                 uint16_t value ) {
112     outl ( CONFIG_CMD ( pci, where ), CONFIG_ADDRESS );
113     outw ( value, CONFIG_DATA + ( where & 2 ) );
114     return 0;
115 }
116
117 static inline int pcidirect_write_config_dword ( struct pci_device *pci,
118                                                  unsigned int where,
119                                                  uint32_t value ) {
120     outl ( CONFIG_CMD ( pci, where ), CONFIG_ADDRESS );
121     outl ( value, CONFIG_DATA );
122     return 0;
123 }
124
125 /*
126  * Functions for accessing PCI configuration space directly via the
127  * PCI BIOS.
128  *
129  * Under -DKEEP_IT_REAL, we use INT 1A, otherwise we use the BIOS32
130  * interface.
131  */
132
133 #ifdef KEEP_IT_REAL
134
135 static void find_pcibios16 ( void ) {
136         uint16_t present;
137         uint32_t signature;
138         uint16_t flags;
139         uint16_t revision;
140         uint8_t max_bus;
141
142         /* PCI BIOS installation check */
143         REAL_EXEC ( rm_pcibios_check,
144                     "int $0x1a\n\t"
145                     "pushfw\n\t"
146                     "popw %%si\n\t",
147                     5,
148                     OUT_CONSTRAINTS ( "=a" ( present ), "=b" ( revision ),
149                                       "=c" ( max_bus ), "=d" ( signature ),
150                                       "=S" ( flags ) ),
151                     IN_CONSTRAINTS ( "a" ( ( PCIBIOS_PCI_FUNCTION_ID << 8 ) +
152                                            PCIBIOS_PCI_BIOS_PRESENT ) ),
153                     CLOBBER ( "edi", "ebp" ) );
154
155         if ( ( flags & CF ) ||
156              ( ( present >> 8 ) != 0 ) ||
157              ( signature != PCI_SIGNATURE ) ) {
158                 DBG ( "PCI BIOS installation check failed\n" );
159                 return;
160         }
161
162         /* We have a PCI BIOS */
163         DBG ( "Found 16-bit PCI BIOS interface with %d buses\n", max_bus + 1 );
164         have_pcibios = 1;
165         pci_max_bus = max_bus;
166         return;
167 }
168
169 INIT_FN ( INIT_PCIBIOS, find_pcibios16, NULL, NULL );
170
171 #define pcibios16_read_write( command, pci, where, value )              \
172         ( {                                                             \
173                 uint32_t discard_b, discard_D;                          \
174                 uint16_t ret;                                           \
175                                                                         \
176                 REAL_EXEC ( 999, /* need a local label */               \
177                             "int $0x1a\n\t"                             \
178                             "jc 1f\n\t"                                 \
179                             "xorw %%ax, %%ax\n\t"                       \
180                             "\n1:\n\t",                                 \
181                             5,                                          \
182                             OUT_CONSTRAINTS ( "=a" ( ret ),             \
183                                               "=b" ( discard_b ),       \
184                                               "=c" ( value ),           \
185                                               "=D" ( discard_D ) ),     \
186                             IN_CONSTRAINTS ( "a" ( command +            \
187                                     ( PCIBIOS_PCI_FUNCTION_ID << 8 ) ), \
188                                              "b" ( pci->busdevfn ),     \
189                                              "c" ( value ),             \
190                                              "D" ( where ) ),           \
191                             CLOBBER ( "edx", "esi", "ebp" ) );          \
192                                                                         \
193                 ( ret >> 8 );                                           \
194         } )
195 #define pcibios_read_write pcibios16_read_write
196
197 #else /* KEEP_IT_REAL */
198
199 /*
200  * Locate the BIOS32 service directory by scanning for a valid BIOS32
201  * structure
202  *
203  */
204 static struct bios32 * find_bios32 ( void ) {
205         uint32_t address;
206
207         /*
208          * Follow the standard procedure for locating the BIOS32 Service
209          * directory by scanning the permissible address range from
210          * 0xe0000 through 0xfffff for a valid BIOS32 structure.
211          *
212          */
213         for ( address = 0xe0000 ; address < 0xffff0 ; address += 16 ) {
214                 struct bios32 * candidate = phys_to_virt ( address );
215                 unsigned int length, i;
216                 unsigned char sum;
217
218                 if ( candidate->signature != BIOS32_SIGNATURE )
219                         continue;
220
221                 length = candidate->length * 16;
222                 if ( ! length )
223                         continue;
224
225                 for ( sum = 0, i = 0 ; i < length ; i++ )
226                         sum += ( ( char * ) candidate ) [i];
227                 if ( sum != 0 )
228                         continue;
229
230                 if ( candidate->revision != 0 ) {
231                         DBG ( "unsupported BIOS32 revision %d at %#x\n",
232                               candidate->revision, address );
233                         continue;
234                 }
235
236                 DBG ( "BIOS32 Service Directory structure at %#x\n", address );
237
238                 return candidate;
239         }
240
241         return NULL;
242 }
243
244 /*
245  * Look up a service in the BIOS32 service directory
246  *
247  */
248 static unsigned long find_bios32_service ( struct bios32 * bios32,
249                                            unsigned long service ) {
250         uint8_t return_code;
251         uint32_t address;
252         uint32_t length;
253         uint32_t entry;
254         uint32_t discard;
255
256         __asm__ ( FLAT_FAR_CALL_ESI
257                   : "=a" ( return_code ), "=b" ( address ),
258                     "=c" ( length ), "=d" ( entry ), "=S" ( discard )
259                   : "a" ( service ), "b" ( 0 ), "S" ( bios32->entry )
260                   : "edi", "ebp" );
261
262         switch ( return_code ) {
263         case BIOS32_SERVICE_PRESENT:
264                 DBG ( "BIOS32 service %c%c%c%c present at %#x\n",
265                       PRINT_BIOS_SIG ( service ), ( address + entry ) );
266                 return ( address + entry );
267         case BIOS32_SERVICE_NOT_PRESENT:
268                 DBG ( "BIOS32 service %c%c%c%c : not present\n",
269                       PRINT_BIOS_SIG ( service ) );
270                 return 0;
271         default: /* Shouldn't happen */
272                 DBG ( "BIOS32 returned %#x for service %c%c%c%c!\n",
273                       return_code, PRINT_BIOS_SIG ( service ) );
274                 return 0;
275         }
276 }
277
278 /*
279  * Find the 32-bit PCI BIOS interface, if present.
280  *
281  */
282 static void find_pcibios32 ( void ) {
283         struct bios32 *bios32;
284         uint32_t signature;
285         uint16_t present;
286         uint32_t flags;
287         uint16_t revision;
288         uint8_t max_bus;
289
290         /* Locate BIOS32 service directory */
291         bios32 = find_bios32 ();
292         if ( ! bios32 ) {
293                 DBG ( "No BIOS32\n" );
294                 return;
295         }
296
297         /* Locate PCI BIOS service */
298         pcibios32_entry = find_bios32_service ( bios32, PCI_SERVICE );
299         if ( ! pcibios32_entry ) {
300                 DBG ( "No PCI BIOS\n" );
301                 return;
302         }
303         
304         /* PCI BIOS installation check */
305         __asm__ ( FLAT_FAR_CALL_ESI
306                   "pushfl\n\t"
307                   "popl %%esi\n\t"
308                   : "=a" ( present ), "=b" ( revision ), "=c" ( max_bus ),
309                     "=d" ( signature ), "=S" ( flags )
310                   : "a" ( ( PCIBIOS_PCI_FUNCTION_ID << 8 )
311                           + PCIBIOS_PCI_BIOS_PRESENT ),
312                     "S" ( pcibios32_entry )
313                   : "edi", "ebp" );
314
315         if ( ( flags & CF ) ||
316              ( ( present >> 8 ) != 0 ) ||
317              ( signature != PCI_SIGNATURE ) ) {
318                 DBG ( "PCI BIOS installation check failed\n" );
319                 return;
320         }
321
322         /* We have a PCI BIOS */
323         DBG ( "Found 32-bit PCI BIOS interface at %#x with %d bus(es)\n",
324               pcibios32_entry, max_bus + 1 );
325         have_pcibios = 1;
326         pci_max_bus = max_bus;
327         return;
328 }
329
330 INIT_FN ( INIT_PCIBIOS, find_pcibios32, NULL, NULL );
331
332 #define pcibios32_read_write( command, pci, where, value )              \
333         ( {                                                             \
334                 uint32_t discard_b, discard_D, discard_S;               \
335                 uint16_t ret;                                           \
336                                                                         \
337                 __asm__ ( FLAT_FAR_CALL_ESI                             \
338                           "jc 1f\n\t"                                   \
339                           "xorl %%eax, %%eax\n\t"                       \
340                           "\n1:\n\t"                                    \
341                           : "=a" ( ret ), "=b" ( discard_b ),           \
342                             "=c" ( value ),                             \
343                             "=S" ( discard_S ), "=D" ( discard_D )      \
344                           : "a" ( ( PCIBIOS_PCI_FUNCTION_ID << 8 )      \
345                                   + command ),                          \
346                             "b" ( pci->busdevfn ), "c" ( value ),       \
347                             "D" ( where ), "S" ( pcibios32_entry )      \
348                           : "edx", "ebp" );                             \
349                                                                         \
350                 ( ret >> 8 );                                           \
351         } )
352 #define pcibios_read_write pcibios32_read_write
353
354 #endif /* KEEP_IT_REAL */
355
356 static inline int pcibios_read_config_byte ( struct pci_device *pci,
357                                              unsigned int where,
358                                              uint8_t *value ) {
359         return pcibios_read_write ( PCIBIOS_READ_CONFIG_BYTE,
360                                     pci, where, *value );
361 }
362
363 static inline int pcibios_read_config_word ( struct pci_device *pci,
364                                              unsigned int where,
365                                              uint16_t *value ) {
366         return pcibios_read_write ( PCIBIOS_READ_CONFIG_WORD,
367                                     pci, where, *value );
368 }
369
370 static inline int pcibios_read_config_dword ( struct pci_device *pci,
371                                               unsigned int where,
372                                               uint32_t *value ) {
373         return pcibios_read_write ( PCIBIOS_READ_CONFIG_DWORD,
374                                     pci, where, *value );
375 }
376
377 static inline int pcibios_write_config_byte ( struct pci_device *pci,
378                                               unsigned int where,
379                                               uint8_t value ) {
380         return pcibios_read_write ( PCIBIOS_WRITE_CONFIG_BYTE,
381                                     pci, where, value );
382 }
383
384 static inline int pcibios_write_config_word ( struct pci_device *pci,
385                                               unsigned int where,
386                                               uint16_t value ) {
387         return pcibios_read_write ( PCIBIOS_WRITE_CONFIG_WORD,
388                                     pci, where, value );
389 }
390
391 static inline int pcibios_write_config_dword ( struct pci_device *pci,
392                                                unsigned int where,
393                                                uint32_t value ) {
394         return pcibios_read_write ( PCIBIOS_WRITE_CONFIG_DWORD,
395                                     pci, where, value );
396 }
397
398 /*
399  * Functions for accessing PCI configuration space via the PCI BIOS if
400  * present, otherwise directly via type 1 accesses.
401  *
402  */
403
404 int pci_read_config_byte ( struct pci_device *pci, unsigned int where,
405                            uint8_t *value ) {
406         return have_pcibios ?
407                 pcibios_read_config_byte ( pci, where, value ) :
408                 pcidirect_read_config_byte ( pci, where, value );
409 }
410                 
411 int pci_read_config_word ( struct pci_device *pci, unsigned int where,
412                            uint16_t *value ) {
413         return have_pcibios ?
414                 pcibios_read_config_word ( pci, where, value ) :
415                 pcidirect_read_config_word ( pci, where, value );
416 }
417                 
418 int pci_read_config_dword ( struct pci_device *pci, unsigned int where,
419                             uint32_t *value ) {
420         return have_pcibios ?
421                 pcibios_read_config_dword ( pci, where, value ) :
422                 pcidirect_read_config_dword ( pci, where, value );
423 }
424                 
425 int pci_write_config_byte ( struct pci_device *pci, unsigned int where,
426                             uint8_t value ) {
427         return have_pcibios ?
428                 pcibios_write_config_byte ( pci, where, value ) :
429                 pcidirect_write_config_byte ( pci, where, value );
430 }
431                 
432 int pci_write_config_word ( struct pci_device *pci, unsigned int where,
433                             uint16_t value ) {
434         return have_pcibios ?
435                 pcibios_write_config_word ( pci, where, value ) :
436                 pcidirect_write_config_word ( pci, where, value );
437 }
438                 
439 int pci_write_config_dword ( struct pci_device *pci, unsigned int where,
440                              uint32_t value ) {
441         return have_pcibios ?
442                 pcibios_write_config_dword ( pci, where, value ) :
443                 pcidirect_write_config_dword ( pci, where, value );
444 }
445
446 unsigned long pci_bus_base ( struct pci_device *pci __unused ) {
447         /* architecturally this must be 0 */
448         return 0;
449 }