Return to caps.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pciutils / lib

Annotation of embedaddon/pciutils/lib/caps.c, revision 1.1.1.1

1.1       misho       1: /*
                      2:  *     The PCI Library -- Capabilities
                      3:  *
                      4:  *     Copyright (c) 2008 Martin Mares <mj@ucw.cz>
                      5:  *
                      6:  *     Can be freely distributed and used under the terms of the GNU GPL.
                      7:  */
                      8: 
                      9: #include <string.h>
                     10: 
                     11: #include "internal.h"
                     12: 
                     13: static void
                     14: pci_add_cap(struct pci_dev *d, unsigned int addr, unsigned int id, unsigned int type)
                     15: {
                     16:   struct pci_cap *cap = pci_malloc(d->access, sizeof(*cap));
                     17: 
                     18:   cap->next = d->first_cap;
                     19:   d->first_cap = cap;
                     20:   cap->addr = addr;
                     21:   cap->id = id;
                     22:   cap->type = type;
                     23:   d->access->debug("%04x:%02x:%02x.%d: Found capability %04x of type %d at %04x\n",
                     24:     d->domain, d->bus, d->dev, d->func, id, type, addr);
                     25: }
                     26: 
                     27: static void
                     28: pci_scan_trad_caps(struct pci_dev *d)
                     29: {
                     30:   word status = pci_read_word(d, PCI_STATUS);
                     31:   byte been_there[256];
                     32:   int where;
                     33: 
                     34:   if (!(status & PCI_STATUS_CAP_LIST))
                     35:     return;
                     36: 
                     37:   memset(been_there, 0, 256);
                     38:   where = pci_read_byte(d, PCI_CAPABILITY_LIST) & ~3;
                     39:   while (where)
                     40:     {
                     41:       byte id = pci_read_byte(d, where + PCI_CAP_LIST_ID);
                     42:       byte next = pci_read_byte(d, where + PCI_CAP_LIST_NEXT) & ~3;
                     43:       if (been_there[where]++)
                     44:        break;
                     45:       if (id == 0xff)
                     46:        break;
                     47:       pci_add_cap(d, where, id, PCI_CAP_NORMAL);
                     48:       where = next;
                     49:     }
                     50: }
                     51: 
                     52: static void
                     53: pci_scan_ext_caps(struct pci_dev *d)
                     54: {
                     55:   byte been_there[0x1000];
                     56:   int where = 0x100;
                     57: 
                     58:   if (!pci_find_cap(d, PCI_CAP_ID_EXP, PCI_CAP_NORMAL))
                     59:     return;
                     60: 
                     61:   memset(been_there, 0, 0x1000);
                     62:   do
                     63:     {
                     64:       u32 header;
                     65:       int id;
                     66: 
                     67:       header = pci_read_long(d, where);
                     68:       if (!header || header == 0xffffffff)
                     69:        break;
                     70:       id = header & 0xffff;
                     71:       if (been_there[where]++)
                     72:        break;
                     73:       pci_add_cap(d, where, id, PCI_CAP_EXTENDED);
                     74:       where = (header >> 20) & ~3;
                     75:     }
                     76:   while (where);
                     77: }
                     78: 
                     79: unsigned int
                     80: pci_scan_caps(struct pci_dev *d, unsigned int want_fields)
                     81: {
                     82:   if ((want_fields & PCI_FILL_EXT_CAPS) && !(d->known_fields & PCI_FILL_CAPS))
                     83:     want_fields |= PCI_FILL_CAPS;
                     84: 
                     85:   if (want_fields & PCI_FILL_CAPS)
                     86:     pci_scan_trad_caps(d);
                     87:   if (want_fields & PCI_FILL_EXT_CAPS)
                     88:     pci_scan_ext_caps(d);
                     89:   return want_fields;
                     90: }
                     91: 
                     92: void
                     93: pci_free_caps(struct pci_dev *d)
                     94: {
                     95:   struct pci_cap *cap;
                     96: 
                     97:   while (cap = d->first_cap)
                     98:     {
                     99:       d->first_cap = cap->next;
                    100:       pci_mfree(cap);
                    101:     }
                    102: }
                    103: 
                    104: struct pci_cap *
                    105: pci_find_cap(struct pci_dev *d, unsigned int id, unsigned int type)
                    106: {
                    107:   struct pci_cap *c;
                    108: 
                    109:   pci_fill_info_v31(d, ((type == PCI_CAP_NORMAL) ? PCI_FILL_CAPS : PCI_FILL_EXT_CAPS));
                    110:   for (c=d->first_cap; c; c=c->next)
                    111:     if (c->type == type && c->id == id)
                    112:       return c;
                    113:   return NULL;
                    114: }