]> mj.ucw.cz Git - pciutils.git/blob - lib/generic.c
(pci_generic_scan_bus): Added work-around for devices with
[pciutils.git] / lib / generic.c
1 /*
2  *      $Id: generic.c,v 1.8 2002/12/27 19:01:51 mj Exp $
3  *
4  *      The PCI Library -- Generic Direct Access Functions
5  *
6  *      Copyright (c) 1997--2000 Martin Mares <mj@ucw.cz>
7  *
8  *      Can be freely distributed and used under the terms of the GNU GPL.
9  */
10
11 #include <string.h>
12
13 #include "internal.h"
14
15 void
16 pci_generic_scan_bus(struct pci_access *a, byte *busmap, int bus)
17 {
18   int dev, multi, ht;
19   struct pci_dev *t = pci_alloc_dev(a);
20
21   a->debug("Scanning bus %02x for devices...\n", bus);
22   if (busmap[bus])
23     {
24       a->warning("Bus %02x seen twice (firmware bug). Ignored.", bus);
25       return;
26     }
27   busmap[bus] = 1;
28   t->bus = bus;
29   for(dev=0; dev<32; dev++)
30     {
31       t->dev = dev;
32       multi = 0;
33       for(t->func=0; !t->func || multi && t->func<8; t->func++)
34         {
35           u32 vd = pci_read_long(t, PCI_VENDOR_ID);
36           struct pci_dev *d;
37
38           if (!vd || vd == 0xffffffff)
39             continue;
40           ht = pci_read_byte(t, PCI_HEADER_TYPE);
41           if (!t->func)
42             multi = ht & 0x80;
43           ht &= 0x7f;
44           d = pci_alloc_dev(a);
45           d->bus = t->bus;
46           d->dev = t->dev;
47           d->func = t->func;
48           d->vendor_id = vd & 0xffff;
49           d->device_id = vd >> 16U;
50           d->known_fields = PCI_FILL_IDENT;
51           d->hdrtype = ht;
52           pci_link_dev(a, d);
53           switch (ht)
54             {
55             case PCI_HEADER_TYPE_NORMAL:
56               break;
57             case PCI_HEADER_TYPE_BRIDGE:
58             case PCI_HEADER_TYPE_CARDBUS:
59               pci_generic_scan_bus(a, busmap, pci_read_byte(t, PCI_SECONDARY_BUS));
60               break;
61             default:
62               a->debug("Device %02x:%02x.%d has unknown header type %02x.\n", d->bus, d->dev, d->func, ht);
63             }
64         }
65     }
66 }
67
68 void
69 pci_generic_scan(struct pci_access *a)
70 {
71   byte busmap[256];
72
73   bzero(busmap, sizeof(busmap));
74   pci_generic_scan_bus(a, busmap, 0);
75 }
76
77 int
78 pci_generic_fill_info(struct pci_dev *d, int flags)
79 {
80   struct pci_access *a = d->access;
81
82   if (flags & PCI_FILL_IDENT)
83     {
84       d->vendor_id = pci_read_word(d, PCI_VENDOR_ID);
85       d->device_id = pci_read_word(d, PCI_DEVICE_ID);
86     }
87   if (flags & PCI_FILL_IRQ)
88     d->irq = pci_read_byte(d, PCI_INTERRUPT_LINE);
89   if (flags & PCI_FILL_BASES)
90     {
91       int cnt = 0, i;
92       bzero(d->base_addr, sizeof(d->base_addr));
93       switch (d->hdrtype)
94         {
95         case PCI_HEADER_TYPE_NORMAL:
96           cnt = 6;
97           break;
98         case PCI_HEADER_TYPE_BRIDGE:
99           cnt = 2;
100           break;
101         case PCI_HEADER_TYPE_CARDBUS:
102           cnt = 1;
103           break;
104         }
105       if (cnt)
106         {
107           u16 cmd = pci_read_word(d, PCI_COMMAND);
108           for(i=0; i<cnt; i++)
109             {
110               u32 x = pci_read_long(d, PCI_BASE_ADDRESS_0 + i*4);
111               if (!x || x == (u32) ~0)
112                 continue;
113               d->base_addr[i] = x;
114               if (x & PCI_BASE_ADDRESS_SPACE_IO)
115                 {
116                   if (!a->buscentric && !(cmd & PCI_COMMAND_IO))
117                     d->base_addr[i] = 0;
118                 }
119               else if (a->buscentric || (cmd & PCI_COMMAND_MEMORY))
120                 {
121                   if ((x & PCI_BASE_ADDRESS_MEM_TYPE_MASK) == PCI_BASE_ADDRESS_MEM_TYPE_64)
122                     {
123                       if (i >= cnt-1)
124                         a->warning("%02x:%02x.%d: Invalid 64-bit address seen.", d->bus, d->dev, d->func);
125                       else
126                         {
127                           u32 y = pci_read_long(d, PCI_BASE_ADDRESS_0 + (++i)*4);
128 #ifdef HAVE_64BIT_ADDRESS
129                           d->base_addr[i-1] |= ((pciaddr_t) y) << 32;
130 #else
131                           if (y)
132                             {
133                               a->warning("%02x:%02x.%d 64-bit device address ignored.", d->bus, d->dev, d->func);
134                               d->base_addr[i-1] = 0;
135                             }
136 #endif
137                         }
138                     }
139                 }
140               else
141                 d->base_addr[i] = 0;
142             }
143         }
144     }
145   if (flags & PCI_FILL_ROM_BASE)
146     {
147       int reg = 0;
148       d->rom_base_addr = 0;
149       switch (d->hdrtype)
150         {
151         case PCI_HEADER_TYPE_NORMAL:
152           reg = PCI_ROM_ADDRESS;
153           break;
154         case PCI_HEADER_TYPE_BRIDGE:
155           reg = PCI_ROM_ADDRESS1;
156           break;
157         }
158       if (reg)
159         {
160           u32 a = pci_read_long(d, reg);
161           if (a & PCI_ROM_ADDRESS_ENABLE)
162             d->rom_base_addr = a;
163         }
164     }
165   return flags & ~PCI_FILL_SIZES;
166 }
167
168 static int
169 pci_generic_block_op(struct pci_dev *d, int pos, byte *buf, int len,
170                  int (*r)(struct pci_dev *d, int pos, byte *buf, int len))
171 {
172   if ((pos & 1) && len >= 1)
173     {
174       if (!r(d, pos, buf, 1))
175         return 0;
176       pos++; buf++; len--;
177     }
178   if ((pos & 3) && len >= 2)
179     {
180       if (!r(d, pos, buf, 2))
181         return 0;
182       pos += 2; buf += 2; len -= 2;
183     }
184   while (len >= 4)
185     {
186       if (!r(d, pos, buf, 4))
187         return 0;
188       pos += 4; buf += 4; len -= 4;
189     }
190   if (len >= 2)
191     {
192       if (!r(d, pos, buf, 2))
193         return 0;
194       pos += 2; buf += 2; len -= 2;
195     }
196   if (len && !r(d, pos, buf, 1))
197     return 0;
198   return 1;
199 }
200
201 int
202 pci_generic_block_read(struct pci_dev *d, int pos, byte *buf, int len)
203 {
204   return pci_generic_block_op(d, pos, buf, len, d->access->methods->read);
205 }
206
207 int
208 pci_generic_block_write(struct pci_dev *d, int pos, byte *buf, int len)
209 {
210   return pci_generic_block_op(d, pos, buf, len, d->access->methods->write);
211 }