118699303709542ac0bee70ee62772e375a93ff1
[people/xl0/syslinux-lua.git] / com32 / lib / pci / scan.c
1 /* ----------------------------------------------------------------------- *
2  *
3  *   Copyright 2006-2007 Erwan Velu - All Rights Reserved
4  *
5  *   Permission is hereby granted, free of charge, to any person
6  *   obtaining a copy of this software and associated documentation
7  *   files (the "Software"), to deal in the Software without
8  *   restriction, including without limitation the rights to use,
9  *   copy, modify, merge, publish, distribute, sublicense, and/or
10  *   sell copies of the Software, and to permit persons to whom
11  *   the Software is furnished to do so, subject to the following
12  *   conditions:
13  *
14  *   The above copyright notice and this permission notice shall
15  *   be included in all copies or substantial portions of the Software.
16  *
17  *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18  *   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
19  *   OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
20  *   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
21  *   HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
22  *   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
23  *   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
24  *   OTHER DEALINGS IN THE SOFTWARE.
25  *
26  * ----------------------------------------------------------------------- */
27
28 /*
29  * pci.c
30  *
31  * A module to extract pci informations
32  */
33
34 #include <inttypes.h>
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <console.h>
39 #include <sys/pci.h>
40 #include <com32.h>
41 #include <stdbool.h>
42
43 #ifdef DEBUG
44 # define dprintf printf
45 #else
46 # define dprintf(...) ((void)0)
47 #endif
48
49 #define MAX_LINE 512
50
51 /* searching the next char that is not a space */
52 static char *skipspace(char *p)
53 {
54   while (*p && *p <= ' ')
55     p++;
56
57   return p;
58 }
59
60 /* removing any \n found in a string */
61 static void remove_eol(char *string)
62 {
63  int j = strlen(string);
64  int i = 0;
65  for(i = 0; i < j; i++) if(string[i] == '\n') string[i] = 0;
66 }
67
68 /* converting a hexa string into its numerical value*/
69 static int hex_to_int(char *hexa)
70 {
71   return strtoul(hexa, NULL, 16);
72 }
73
74 /* Try to match any pci device to the appropriate kernel module */
75 /* it uses the modules.pcimap from the boot device*/
76 void get_module_name_from_pci_ids(struct pci_device_list *pci_device_list)
77 {
78   char line[MAX_LINE];
79   char module_name[21]; // the module name field is 21 char long
80   char delims[]=" ";    // colums are separated by spaces
81   char vendor_id[16];
82   char product_id[16];
83   char sub_vendor_id[16];
84   char sub_product_id[16];
85   FILE *f;
86   int pci_dev;
87
88   /* Intializing the linux_kernel_module for each pci device to "unknow" */
89   /* adding a pci_dev_info member if needed*/
90   for (pci_dev=0; pci_dev < pci_device_list->count; pci_dev++) {
91     struct pci_device *pci_device = &(pci_device_list->pci_device[pci_dev]);
92
93     /* initialize the pci_dev_info structure if it doesn't exist yet. */
94     if (! pci_device->pci_dev_info) {
95       pci_device->pci_dev_info = calloc(1,sizeof (struct pci_device));
96       if (!pci_device->pci_dev_info) {
97         printf("Can't allocate memory\n");
98         return;
99       }
100     }
101     pci_device->pci_dev_info->linux_kernel_module=strdup("unknown");
102   }
103
104   /* Opening the modules.pcimap (ofa linux kernel) from the boot device*/
105   f=fopen("modules.pcimap","r");
106   if (!f)
107     return;
108
109   strcpy(vendor_id,"0000");
110   strcpy(product_id,"0000");
111   strcpy(sub_product_id,"0000");
112   strcpy(sub_vendor_id,"0000");
113
114   /* for each line we found in the modules.pcimap*/
115   while ( fgets(line, sizeof line, f) ) {
116     /*skipping unecessary lines */
117     if ((line[0] == '#') || (line[0] == ' ') || (line[0] == 10))
118         continue;
119
120     char *result = NULL;
121     int field=0;
122
123     /* looking for the next field */
124     result = strtok(line, delims);
125     while( result != NULL ) {
126        /* if the column is larger than 1 char */
127        /* multiple spaces generates some empty fields*/
128        if (strlen(result)>1) {
129          switch (field) {
130          case 0:strcpy(module_name,result); break;
131          case 1:strcpy(vendor_id,result); break;
132          case 2:strcpy(product_id,result); break;
133          case 3:strcpy(sub_vendor_id,result); break;
134          case 4:strcpy(sub_product_id,result); break;
135          }
136          field++;
137        }
138        /* Searching the next field*/
139        result = strtok( NULL, delims );
140    }
141     /* if a pci_device match an entry, fill the linux_kernel_module with
142        the appropriate kernel module */
143     for (pci_dev=0; pci_dev < pci_device_list->count; pci_dev++) {
144       struct pci_device *pci_device =
145         &pci_device_list->pci_device[pci_dev];
146
147       if (hex_to_int(vendor_id) == pci_device->vendor &&
148           hex_to_int(product_id) == pci_device->product &&
149           (hex_to_int(sub_product_id) & pci_device->sub_product)
150           == pci_device->sub_product &&
151           (hex_to_int(sub_vendor_id) & pci_device->sub_vendor)
152           == pci_device->sub_vendor)
153         strcpy(pci_device->pci_dev_info->linux_kernel_module,
154                module_name);
155     }
156   }
157  fclose(f);
158 }
159
160 /* Try to match any pci device to the appropriate vendor and product name */
161 /* it uses the pci.ids from the boot device*/
162 void get_name_from_pci_ids(struct pci_device_list *pci_device_list)
163 {
164   char line[MAX_LINE];
165   char *vendor=NULL;
166   char vendor_id[5];
167   char *product=NULL;
168   char product_id[5];
169   char sub_product_id[5];
170   char sub_vendor_id[5];
171   FILE *f;
172   int pci_dev;
173
174  /* Intializing the vendor/product name for each pci device to "unknow" */
175  /* adding a pci_dev_info member if needed*/
176  for (pci_dev=0; pci_dev < pci_device_list->count; pci_dev++) {
177     struct pci_device *pci_device = &pci_device_list->pci_device[pci_dev];
178
179     /* initialize the pci_dev_info structure if it doesn't exist yet. */
180     if (! pci_device->pci_dev_info) {
181       pci_device->pci_dev_info = calloc(1,sizeof (struct pci_device));
182
183       if (!pci_device->pci_dev_info) {
184         printf("Can't allocate memory\n");
185         return;
186       }
187     }
188
189     pci_device->pci_dev_info->vendor_name=strdup("unknown");
190     pci_device->pci_dev_info->product_name=strdup("unknown");
191   }
192
193   /* Opening the pci.ids from the boot device*/
194   f=fopen("pci.ids","r");
195   if (!f)
196         return;
197
198   strcpy(vendor_id,"0000");
199   strcpy(product_id,"0000");
200   strcpy(sub_product_id,"0000");
201   strcpy(sub_vendor_id,"0000");
202
203
204   /* for each line we found in the pci.ids*/
205   while ( fgets(line, sizeof line, f) ) {
206
207     /* Skipping uncessary lines */
208     if ((line[0] == '#') || (line[0] == ' ') || (line[0] == 'C') ||
209         (line[0] == 10))
210         continue;
211     /* If the line doesn't start with a tab, it means that's a vendor id */
212     if (line[0] != '\t') {
213
214         /* the 4th first chars are the vendor_id */
215         strncpy(vendor_id,line,4);
216
217         /* the vendor name is the next field*/
218         vendor_id[4]=0;
219         vendor=strdup(skipspace(strstr(line," ")));
220         remove_eol(vendor);
221
222         /* init product_id, sub_product and sub_vendor */
223         strcpy(product_id,"0000");
224         strcpy(sub_product_id,"0000");
225         strcpy(sub_vendor_id,"0000");
226
227         /* ffff is an invalid vendor id */
228         if (strstr(vendor_id,"ffff")) break;
229
230         /* assign the vendor_name to any matching pci device*/
231         for (pci_dev=0; pci_dev < pci_device_list->count; pci_dev++) {
232           struct pci_device *pci_device =
233             &pci_device_list->pci_device[pci_dev];
234
235           if (hex_to_int(vendor_id) == pci_device->vendor)
236             pci_device->pci_dev_info->vendor_name=strdup(vendor);
237         }
238     /* if we have a tab + a char, it means this is a product id */
239     } else if ((line[0] == '\t') && (line[1] != '\t')) {
240
241         /* the product name the second field */
242         product=strdup(skipspace(strstr(line," ")));
243         remove_eol(product);
244
245         /* the product id is first field */
246         strncpy(product_id,&line[1],4);
247         product_id[4]=0;
248
249         /* init sub_product and sub_vendor */
250         strcpy(sub_product_id,"0000");
251         strcpy(sub_vendor_id,"0000");
252
253         /* assign the product_name to any matching pci device*/
254         for (pci_dev=0; pci_dev < pci_device_list->count; pci_dev++) {
255           struct pci_device *pci_device =
256             &pci_device_list->pci_device[pci_dev];
257           if (hex_to_int(vendor_id) == pci_device->vendor &&
258               hex_to_int(product_id) == pci_device->product)
259             pci_device->pci_dev_info->product_name=strdup(product);
260         }
261
262     /* if we have two tabs, it means this is a sub product */
263     } else if ((line[0] == '\t') && (line[1] == '\t')) {
264
265       /* the product name is last field */
266       product=skipspace(strstr(line," "));
267       product=strdup(skipspace(strstr(product," ")));
268       remove_eol(product);
269
270       /* the sub_vendor id is first field */
271       strncpy(sub_vendor_id,&line[2],4);
272       sub_vendor_id[4]=0;
273
274       /* the sub_vendor id is second field */
275       strncpy(sub_product_id,&line[7],4);
276       sub_product_id[4]=0;
277
278       /* assign the product_name to any matching pci device*/
279       for (pci_dev=0; pci_dev < pci_device_list->count; pci_dev++) {
280         struct pci_device *pci_device =
281           &pci_device_list->pci_device[pci_dev];
282
283         if (hex_to_int(vendor_id) == pci_device->vendor &&
284             hex_to_int(product_id) == pci_device->product &&
285             hex_to_int(sub_product_id) == pci_device->sub_product &&
286             hex_to_int(sub_vendor_id) == pci_device->sub_vendor)
287           pci_device->pci_dev_info->product_name=strdup(product);
288       }
289     }
290   }
291   fclose(f);
292 }
293
294 /* searching if any pcidevice match our query */
295 struct match *find_pci_device(struct pci_device_list * pci_device_list,
296                               struct match *list)
297 {
298   int pci_dev;
299   uint32_t did, sid;
300   struct match *m;
301   /* for all matches we have to search */
302   for (m = list; m; m = m->next) {
303           /* for each pci device we know */
304     for (pci_dev = 0; pci_dev < pci_device_list->count; pci_dev++) {
305       struct pci_device *pci_device =
306         &pci_device_list->pci_device[pci_dev];
307
308       /* sid & did are the easiest way to compare devices */
309       /* they are made of vendor/product subvendor/subproduct ids */
310       sid =
311         ((pci_device->sub_product) << 16 | (pci_device->
312                                             sub_vendor));
313       did = ((pci_device->product << 16) | (pci_device->vendor));
314
315       /*if the current device match */
316       if (((did ^ m->did) & m->did_mask) == 0 &&
317           ((sid ^ m->sid) & m->sid_mask) == 0 &&
318           pci_device->revision >= m->rid_min
319           && pci_device->revision <= m->rid_max) {
320         dprintf("PCI Match: Vendor=%04x Product=%04x Sub_vendor=%04x Sub_Product=%04x Release=%02x\n",
321                 pci_device->vendor, pci_device->product,
322                 pci_device->sub_vendor,
323                 pci_device->sub_product,
324                 pci_device->revision);
325         /* returning the matched pci device */
326         return m;
327       }
328     }
329   }
330   return NULL;
331 }
332
333 /* scanning the pci bus to find pci devices */
334 int pci_scan(struct pci_bus_list * pci_bus_list, struct pci_device_list * pci_device_list)
335 {
336   unsigned int bus, dev, func, maxfunc;
337   uint32_t did, sid;
338   uint8_t hdrtype, rid;
339   pciaddr_t a;
340   int cfgtype;
341
342   pci_device_list->count = 0;
343
344 #ifdef DEBUG
345   outl(~0, 0xcf8);
346   printf("Poking at port CF8 = %#08x\n", inl(0xcf8));
347   outl(0, 0xcf8);
348 #endif
349
350   cfgtype = pci_set_config_type(PCI_CFG_AUTO);
351   (void)cfgtype;
352
353   dprintf("PCI configuration type %d\n", cfgtype);
354   dprintf("Scanning PCI Buses\n");
355
356   /* We try to detect 255 buses */
357   for (bus = 0; bus <= MAX_PCI_BUSES; bus++) {
358
359     dprintf("Probing bus 0x%02x... \n", bus);
360
361     pci_bus_list->pci_bus[bus].id = bus;
362     pci_bus_list->pci_bus[bus].pci_device_count = 0;
363     pci_bus_list->count = 0;;
364
365     for (dev = 0; dev <= 0x1f; dev++) {
366       maxfunc = 0;
367       for (func = 0; func <= maxfunc; func++) {
368         a = pci_mkaddr(bus, dev, func, 0);
369
370         did = pci_readl(a);
371
372         if (did == 0xffffffff || did == 0xffff0000 ||
373             did == 0x0000ffff || did == 0x00000000)
374           continue;
375
376         hdrtype = pci_readb(a + 0x0e);
377
378         if (hdrtype & 0x80)
379           maxfunc = 7;  /* Multifunction device */
380
381         rid = pci_readb(a + 0x08);
382         sid = pci_readl(a + 0x2c);
383         struct pci_device *pci_device =
384           &pci_device_list->
385           pci_device[pci_device_list->count];
386         pci_device->product = did >> 16;
387         pci_device->sub_product = sid >> 16;
388         pci_device->vendor = (did << 16) >> 16;
389         pci_device->sub_vendor = (sid << 16) >> 16;
390         pci_device->revision = rid;
391         pci_device_list->count++;
392         dprintf
393           ("Scanning: BUS %02x DID %08x (%04x:%04x) SID %08x RID %02x\n",
394            bus, did, did >> 16, (did << 16) >> 16,
395            sid, rid);
396         /* Adding the detected pci device to the bus */
397         pci_bus_list->pci_bus[bus].
398           pci_device[pci_bus_list->pci_bus[bus].
399                      pci_device_count] = pci_device;
400         pci_bus_list->pci_bus[bus].pci_device_count++;
401       }
402     }
403   }
404
405   /* Detecting pci buses that have pci devices connected */
406   for (bus = 0; bus <= 0xff; bus++) {
407     if (pci_bus_list->pci_bus[bus].pci_device_count > 0) {
408       pci_bus_list->count++;
409     }
410   }
411   return 0;
412 }