Rev 5271 | Rev 6321 | Go to most recent revision | Only display areas with differences | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed
Rev 5271 | Rev 6104 | ||
---|---|---|---|
- | 1 | #define CONFIG_PCI |
|
- | 2 | ||
- | 3 | #include |
|
1 | #include |
4 | |
2 | #include |
5 | #include |
3 | #include |
6 | #include |
4 | #include |
7 | #include |
5 | #include |
8 | #include |
- | 9 | #include |
|
- | 10 | ||
6 | #include |
11 | #include |
7 | - | ||
- | 12 | ||
8 | extern int pci_scan_filter(u32 id, u32 busnr, u32 devfn); |
13 | |
9 | 14 | extern int pci_scan_filter(u32 id, u32 busnr, u32 devfn); |
|
10 | static LIST_HEAD(devices); |
15 | |
11 | 16 | static LIST_HEAD(devices); |
|
12 | /* PCI control bits. Shares IORESOURCE_BITS with above PCI ROM. */ |
17 | |
13 | #define IORESOURCE_PCI_FIXED (1<<4) /* Do not move resource */ |
18 | /* PCI control bits. Shares IORESOURCE_BITS with above PCI ROM. */ |
14 | 19 | #define IORESOURCE_PCI_FIXED (1<<4) /* Do not move resource */ |
|
15 | #define LEGACY_IO_RESOURCE (IORESOURCE_IO | IORESOURCE_PCI_FIXED) |
20 | |
16 | 21 | #define LEGACY_IO_RESOURCE (IORESOURCE_IO | IORESOURCE_PCI_FIXED) |
|
17 | /* |
22 | |
18 | * Translate the low bits of the PCI base |
23 | /* |
19 | * to the resource type |
24 | * Translate the low bits of the PCI base |
20 | */ |
25 | * to the resource type |
21 | static inline unsigned int pci_calc_resource_flags(unsigned int flags) |
26 | */ |
22 | { |
27 | static inline unsigned int pci_calc_resource_flags(unsigned int flags) |
23 | if (flags & PCI_BASE_ADDRESS_SPACE_IO) |
28 | { |
24 | return IORESOURCE_IO; |
29 | if (flags & PCI_BASE_ADDRESS_SPACE_IO) |
25 | 30 | return IORESOURCE_IO; |
|
26 | if (flags & PCI_BASE_ADDRESS_MEM_PREFETCH) |
31 | |
27 | return IORESOURCE_MEM | IORESOURCE_PREFETCH; |
32 | if (flags & PCI_BASE_ADDRESS_MEM_PREFETCH) |
28 | 33 | return IORESOURCE_MEM | IORESOURCE_PREFETCH; |
|
29 | return IORESOURCE_MEM; |
34 | |
30 | } |
35 | return IORESOURCE_MEM; |
31 | 36 | } |
|
32 | 37 | ||
33 | static u32 pci_size(u32 base, u32 maxbase, u32 mask) |
38 | |
34 | { |
39 | static u32 pci_size(u32 base, u32 maxbase, u32 mask) |
35 | u32 size = mask & maxbase; /* Find the significant bits */ |
40 | { |
36 | 41 | u32 size = mask & maxbase; /* Find the significant bits */ |
|
37 | if (!size) |
42 | |
38 | return 0; |
43 | if (!size) |
39 | 44 | return 0; |
|
40 | /* Get the lowest of them to find the decode size, and |
45 | |
41 | from that the extent. */ |
46 | /* Get the lowest of them to find the decode size, and |
42 | size = (size & ~(size-1)) - 1; |
47 | from that the extent. */ |
43 | 48 | size = (size & ~(size-1)) - 1; |
|
44 | /* base == maxbase can be valid only if the BAR has |
49 | |
45 | already been programmed with all 1s. */ |
50 | /* base == maxbase can be valid only if the BAR has |
46 | if (base == maxbase && ((base | size) & mask) != mask) |
51 | already been programmed with all 1s. */ |
47 | return 0; |
52 | if (base == maxbase && ((base | size) & mask) != mask) |
48 | 53 | return 0; |
|
49 | return size; |
54 | |
50 | } |
55 | return size; |
51 | 56 | } |
|
52 | static u64 pci_size64(u64 base, u64 maxbase, u64 mask) |
57 | |
53 | { |
58 | static u64 pci_size64(u64 base, u64 maxbase, u64 mask) |
54 | u64 size = mask & maxbase; /* Find the significant bits */ |
59 | { |
55 | 60 | u64 size = mask & maxbase; /* Find the significant bits */ |
|
56 | if (!size) |
61 | |
57 | return 0; |
62 | if (!size) |
58 | 63 | return 0; |
|
59 | /* Get the lowest of them to find the decode size, and |
64 | |
60 | from that the extent. */ |
65 | /* Get the lowest of them to find the decode size, and |
61 | size = (size & ~(size-1)) - 1; |
66 | from that the extent. */ |
62 | 67 | size = (size & ~(size-1)) - 1; |
|
63 | /* base == maxbase can be valid only if the BAR has |
68 | |
64 | already been programmed with all 1s. */ |
69 | /* base == maxbase can be valid only if the BAR has |
65 | if (base == maxbase && ((base | size) & mask) != mask) |
70 | already been programmed with all 1s. */ |
66 | return 0; |
71 | if (base == maxbase && ((base | size) & mask) != mask) |
67 | 72 | return 0; |
|
68 | return size; |
73 | |
69 | } |
74 | return size; |
70 | 75 | } |
|
71 | static inline int is_64bit_memory(u32 mask) |
76 | |
72 | { |
77 | static inline int is_64bit_memory(u32 mask) |
73 | if ((mask & (PCI_BASE_ADDRESS_SPACE|PCI_BASE_ADDRESS_MEM_TYPE_MASK)) == |
78 | { |
74 | (PCI_BASE_ADDRESS_SPACE_MEMORY|PCI_BASE_ADDRESS_MEM_TYPE_64)) |
79 | if ((mask & (PCI_BASE_ADDRESS_SPACE|PCI_BASE_ADDRESS_MEM_TYPE_MASK)) == |
75 | return 1; |
80 | (PCI_BASE_ADDRESS_SPACE_MEMORY|PCI_BASE_ADDRESS_MEM_TYPE_64)) |
76 | return 0; |
81 | return 1; |
77 | } |
82 | return 0; |
78 | 83 | } |
|
79 | static void pci_read_bases(struct pci_dev *dev, unsigned int howmany, int rom) |
84 | |
80 | { |
85 | static void pci_read_bases(struct pci_dev *dev, unsigned int howmany, int rom) |
81 | u32 pos, reg, next; |
86 | { |
82 | u32 l, sz; |
87 | u32 pos, reg, next; |
83 | struct resource *res; |
88 | u32 l, sz; |
84 | 89 | struct resource *res; |
|
85 | for(pos=0; pos < howmany; pos = next) |
90 | |
86 | { |
91 | for(pos=0; pos < howmany; pos = next) |
87 | u64 l64; |
92 | { |
88 | u64 sz64; |
93 | u64 l64; |
89 | u32 raw_sz; |
94 | u64 sz64; |
90 | 95 | u32 raw_sz; |
|
91 | next = pos + 1; |
96 | |
92 | 97 | next = pos + 1; |
|
93 | res = &dev->resource[pos]; |
98 | |
94 | 99 | res = &dev->resource[pos]; |
|
95 | reg = PCI_BASE_ADDRESS_0 + (pos << 2); |
100 | |
96 | l = PciRead32(dev->busnr, dev->devfn, reg); |
101 | reg = PCI_BASE_ADDRESS_0 + (pos << 2); |
97 | PciWrite32(dev->busnr, dev->devfn, reg, ~0); |
102 | l = PciRead32(dev->busnr, dev->devfn, reg); |
98 | sz = PciRead32(dev->busnr, dev->devfn, reg); |
103 | PciWrite32(dev->busnr, dev->devfn, reg, ~0); |
99 | PciWrite32(dev->busnr, dev->devfn, reg, l); |
104 | sz = PciRead32(dev->busnr, dev->devfn, reg); |
100 | 105 | PciWrite32(dev->busnr, dev->devfn, reg, l); |
|
101 | if (!sz || sz == 0xffffffff) |
106 | |
102 | continue; |
107 | if (!sz || sz == 0xffffffff) |
103 | 108 | continue; |
|
104 | if (l == 0xffffffff) |
109 | |
105 | l = 0; |
110 | if (l == 0xffffffff) |
106 | 111 | l = 0; |
|
107 | raw_sz = sz; |
112 | |
108 | if ((l & PCI_BASE_ADDRESS_SPACE) == |
113 | raw_sz = sz; |
109 | PCI_BASE_ADDRESS_SPACE_MEMORY) |
114 | if ((l & PCI_BASE_ADDRESS_SPACE) == |
110 | { |
115 | PCI_BASE_ADDRESS_SPACE_MEMORY) |
111 | sz = pci_size(l, sz, (u32)PCI_BASE_ADDRESS_MEM_MASK); |
116 | { |
112 | /* |
117 | sz = pci_size(l, sz, (u32)PCI_BASE_ADDRESS_MEM_MASK); |
113 | * For 64bit prefetchable memory sz could be 0, if the |
118 | /* |
114 | * real size is bigger than 4G, so we need to check |
119 | * For 64bit prefetchable memory sz could be 0, if the |
115 | * szhi for that. |
120 | * real size is bigger than 4G, so we need to check |
116 | */ |
121 | * szhi for that. |
117 | if (!is_64bit_memory(l) && !sz) |
122 | */ |
118 | continue; |
123 | if (!is_64bit_memory(l) && !sz) |
119 | res->start = l & PCI_BASE_ADDRESS_MEM_MASK; |
124 | continue; |
120 | res->flags |= l & ~PCI_BASE_ADDRESS_MEM_MASK; |
125 | res->start = l & PCI_BASE_ADDRESS_MEM_MASK; |
121 | } |
126 | res->flags |= l & ~PCI_BASE_ADDRESS_MEM_MASK; |
122 | else { |
127 | } |
123 | sz = pci_size(l, sz, PCI_BASE_ADDRESS_IO_MASK & 0xffff); |
128 | else { |
124 | if (!sz) |
129 | sz = pci_size(l, sz, PCI_BASE_ADDRESS_IO_MASK & 0xffff); |
125 | continue; |
130 | if (!sz) |
126 | res->start = l & PCI_BASE_ADDRESS_IO_MASK; |
131 | continue; |
127 | res->flags |= l & ~PCI_BASE_ADDRESS_IO_MASK; |
132 | res->start = l & PCI_BASE_ADDRESS_IO_MASK; |
128 | } |
133 | res->flags |= l & ~PCI_BASE_ADDRESS_IO_MASK; |
129 | res->end = res->start + (unsigned long) sz; |
134 | } |
130 | res->flags |= pci_calc_resource_flags(l); |
135 | res->end = res->start + (unsigned long) sz; |
131 | if (is_64bit_memory(l)) |
136 | res->flags |= pci_calc_resource_flags(l); |
132 | { |
137 | if (is_64bit_memory(l)) |
133 | u32 szhi, lhi; |
138 | { |
134 | 139 | u32 szhi, lhi; |
|
135 | lhi = PciRead32(dev->busnr, dev->devfn, reg+4); |
140 | |
136 | PciWrite32(dev->busnr, dev->devfn, reg+4, ~0); |
141 | lhi = PciRead32(dev->busnr, dev->devfn, reg+4); |
137 | szhi = PciRead32(dev->busnr, dev->devfn, reg+4); |
142 | PciWrite32(dev->busnr, dev->devfn, reg+4, ~0); |
138 | PciWrite32(dev->busnr, dev->devfn, reg+4, lhi); |
143 | szhi = PciRead32(dev->busnr, dev->devfn, reg+4); |
139 | sz64 = ((u64)szhi << 32) | raw_sz; |
144 | PciWrite32(dev->busnr, dev->devfn, reg+4, lhi); |
140 | l64 = ((u64)lhi << 32) | l; |
145 | sz64 = ((u64)szhi << 32) | raw_sz; |
141 | sz64 = pci_size64(l64, sz64, PCI_BASE_ADDRESS_MEM_MASK); |
146 | l64 = ((u64)lhi << 32) | l; |
142 | next++; |
147 | sz64 = pci_size64(l64, sz64, PCI_BASE_ADDRESS_MEM_MASK); |
143 | 148 | next++; |
|
144 | #if BITS_PER_LONG == 64 |
149 | |
145 | if (!sz64) { |
150 | #if BITS_PER_LONG == 64 |
146 | res->start = 0; |
151 | if (!sz64) { |
147 | res->end = 0; |
152 | res->start = 0; |
148 | res->flags = 0; |
153 | res->end = 0; |
149 | continue; |
154 | res->flags = 0; |
150 | } |
155 | continue; |
151 | res->start = l64 & PCI_BASE_ADDRESS_MEM_MASK; |
156 | } |
152 | res->end = res->start + sz64; |
157 | res->start = l64 & PCI_BASE_ADDRESS_MEM_MASK; |
153 | #else |
158 | res->end = res->start + sz64; |
154 | if (sz64 > 0x100000000ULL) { |
159 | #else |
155 | printk(KERN_ERR "PCI: Unable to handle 64-bit " |
160 | if (sz64 > 0x100000000ULL) { |
156 | "BAR for device %s\n", pci_name(dev)); |
161 | printk(KERN_ERR "PCI: Unable to handle 64-bit " |
157 | res->start = 0; |
162 | "BAR for device %s\n", pci_name(dev)); |
158 | res->flags = 0; |
163 | res->start = 0; |
159 | } |
164 | res->flags = 0; |
160 | else if (lhi) |
165 | } |
161 | { |
166 | else if (lhi) |
162 | /* 64-bit wide address, treat as disabled */ |
167 | { |
163 | PciWrite32(dev->busnr, dev->devfn, reg, |
168 | /* 64-bit wide address, treat as disabled */ |
164 | l & ~(u32)PCI_BASE_ADDRESS_MEM_MASK); |
169 | PciWrite32(dev->busnr, dev->devfn, reg, |
165 | PciWrite32(dev->busnr, dev->devfn, reg+4, 0); |
170 | l & ~(u32)PCI_BASE_ADDRESS_MEM_MASK); |
166 | res->start = 0; |
171 | PciWrite32(dev->busnr, dev->devfn, reg+4, 0); |
167 | res->end = sz; |
172 | res->start = 0; |
168 | } |
173 | res->end = sz; |
169 | #endif |
174 | } |
170 | } |
175 | #endif |
171 | } |
176 | } |
172 | 177 | } |
|
173 | if ( rom ) |
178 | |
174 | { |
179 | if ( rom ) |
175 | dev->rom_base_reg = rom; |
180 | { |
176 | res = &dev->resource[PCI_ROM_RESOURCE]; |
181 | dev->rom_base_reg = rom; |
177 | 182 | res = &dev->resource[PCI_ROM_RESOURCE]; |
|
178 | l = PciRead32(dev->busnr, dev->devfn, rom); |
183 | |
179 | PciWrite32(dev->busnr, dev->devfn, rom, ~PCI_ROM_ADDRESS_ENABLE); |
184 | l = PciRead32(dev->busnr, dev->devfn, rom); |
180 | sz = PciRead32(dev->busnr, dev->devfn, rom); |
185 | PciWrite32(dev->busnr, dev->devfn, rom, ~PCI_ROM_ADDRESS_ENABLE); |
181 | PciWrite32(dev->busnr, dev->devfn, rom, l); |
186 | sz = PciRead32(dev->busnr, dev->devfn, rom); |
182 | 187 | PciWrite32(dev->busnr, dev->devfn, rom, l); |
|
183 | if (l == 0xffffffff) |
188 | |
184 | l = 0; |
189 | if (l == 0xffffffff) |
185 | 190 | l = 0; |
|
186 | if (sz && sz != 0xffffffff) |
191 | |
187 | { |
192 | if (sz && sz != 0xffffffff) |
188 | sz = pci_size(l, sz, (u32)PCI_ROM_ADDRESS_MASK); |
193 | { |
189 | 194 | sz = pci_size(l, sz, (u32)PCI_ROM_ADDRESS_MASK); |
|
190 | if (sz) |
195 | |
191 | { |
196 | if (sz) |
192 | res->flags = (l & IORESOURCE_ROM_ENABLE) | |
197 | { |
193 | IORESOURCE_MEM | IORESOURCE_PREFETCH | |
198 | res->flags = (l & IORESOURCE_ROM_ENABLE) | |
194 | IORESOURCE_READONLY | IORESOURCE_CACHEABLE; |
199 | IORESOURCE_MEM | IORESOURCE_PREFETCH | |
195 | res->start = l & PCI_ROM_ADDRESS_MASK; |
200 | IORESOURCE_READONLY | IORESOURCE_CACHEABLE; |
196 | res->end = res->start + (unsigned long) sz; |
201 | res->start = l & PCI_ROM_ADDRESS_MASK; |
197 | } |
202 | res->end = res->start + (unsigned long) sz; |
198 | } |
203 | } |
199 | } |
204 | } |
200 | } |
205 | } |
201 | 206 | } |
|
202 | static void pci_read_irq(struct pci_dev *dev) |
207 | |
203 | { |
208 | static void pci_read_irq(struct pci_dev *dev) |
204 | u8 irq; |
209 | { |
205 | 210 | u8 irq; |
|
206 | irq = PciRead8(dev->busnr, dev->devfn, PCI_INTERRUPT_PIN); |
211 | |
207 | dev->pin = irq; |
212 | irq = PciRead8(dev->busnr, dev->devfn, PCI_INTERRUPT_PIN); |
208 | if (irq) |
213 | dev->pin = irq; |
209 | irq = PciRead8(dev->busnr, dev->devfn, PCI_INTERRUPT_LINE); |
214 | if (irq) |
210 | dev->irq = irq; |
215 | irq = PciRead8(dev->busnr, dev->devfn, PCI_INTERRUPT_LINE); |
211 | }; |
216 | dev->irq = irq; |
212 | 217 | }; |
|
213 | 218 | ||
214 | int pci_setup_device(struct pci_dev *dev) |
219 | |
215 | { |
220 | int pci_setup_device(struct pci_dev *dev) |
216 | u32 class; |
221 | { |
217 | 222 | u32 class; |
|
218 | class = PciRead32(dev->busnr, dev->devfn, PCI_CLASS_REVISION); |
223 | |
219 | dev->revision = class & 0xff; |
224 | class = PciRead32(dev->busnr, dev->devfn, PCI_CLASS_REVISION); |
220 | class >>= 8; /* upper 3 bytes */ |
225 | dev->revision = class & 0xff; |
221 | dev->class = class; |
226 | class >>= 8; /* upper 3 bytes */ |
222 | 227 | dev->class = class; |
|
223 | /* "Unknown power state" */ |
228 | |
224 | // dev->current_state = PCI_UNKNOWN; |
229 | /* "Unknown power state" */ |
225 | 230 | // dev->current_state = PCI_UNKNOWN; |
|
226 | /* Early fixups, before probing the BARs */ |
231 | |
227 | // pci_fixup_device(pci_fixup_early, dev); |
232 | /* Early fixups, before probing the BARs */ |
228 | class = dev->class >> 8; |
233 | // pci_fixup_device(pci_fixup_early, dev); |
229 | 234 | class = dev->class >> 8; |
|
230 | switch (dev->hdr_type) |
235 | |
231 | { |
236 | switch (dev->hdr_type) |
232 | case PCI_HEADER_TYPE_NORMAL: /* standard header */ |
237 | { |
233 | if (class == PCI_CLASS_BRIDGE_PCI) |
238 | case PCI_HEADER_TYPE_NORMAL: /* standard header */ |
234 | goto bad; |
239 | if (class == PCI_CLASS_BRIDGE_PCI) |
235 | pci_read_irq(dev); |
240 | goto bad; |
236 | pci_read_bases(dev, 6, PCI_ROM_ADDRESS); |
241 | pci_read_irq(dev); |
237 | dev->subsystem_vendor = PciRead16(dev->busnr, dev->devfn,PCI_SUBSYSTEM_VENDOR_ID); |
242 | pci_read_bases(dev, 6, PCI_ROM_ADDRESS); |
238 | dev->subsystem_device = PciRead16(dev->busnr, dev->devfn, PCI_SUBSYSTEM_ID); |
243 | dev->subsystem_vendor = PciRead16(dev->busnr, dev->devfn,PCI_SUBSYSTEM_VENDOR_ID); |
239 | 244 | dev->subsystem_device = PciRead16(dev->busnr, dev->devfn, PCI_SUBSYSTEM_ID); |
|
240 | /* |
245 | |
241 | * Do the ugly legacy mode stuff here rather than broken chip |
246 | /* |
242 | * quirk code. Legacy mode ATA controllers have fixed |
247 | * Do the ugly legacy mode stuff here rather than broken chip |
243 | * addresses. These are not always echoed in BAR0-3, and |
248 | * quirk code. Legacy mode ATA controllers have fixed |
244 | * BAR0-3 in a few cases contain junk! |
249 | * addresses. These are not always echoed in BAR0-3, and |
245 | */ |
250 | * BAR0-3 in a few cases contain junk! |
246 | if (class == PCI_CLASS_STORAGE_IDE) |
251 | */ |
247 | { |
252 | if (class == PCI_CLASS_STORAGE_IDE) |
248 | u8 progif; |
253 | { |
249 | 254 | u8 progif; |
|
250 | progif = PciRead8(dev->busnr, dev->devfn,PCI_CLASS_PROG); |
255 | |
251 | if ((progif & 1) == 0) |
256 | progif = PciRead8(dev->busnr, dev->devfn,PCI_CLASS_PROG); |
252 | { |
257 | if ((progif & 1) == 0) |
253 | dev->resource[0].start = 0x1F0; |
258 | { |
254 | dev->resource[0].end = 0x1F7; |
259 | dev->resource[0].start = 0x1F0; |
255 | dev->resource[0].flags = LEGACY_IO_RESOURCE; |
260 | dev->resource[0].end = 0x1F7; |
256 | dev->resource[1].start = 0x3F6; |
261 | dev->resource[0].flags = LEGACY_IO_RESOURCE; |
257 | dev->resource[1].end = 0x3F6; |
262 | dev->resource[1].start = 0x3F6; |
258 | dev->resource[1].flags = LEGACY_IO_RESOURCE; |
263 | dev->resource[1].end = 0x3F6; |
259 | } |
264 | dev->resource[1].flags = LEGACY_IO_RESOURCE; |
260 | if ((progif & 4) == 0) |
265 | } |
261 | { |
266 | if ((progif & 4) == 0) |
262 | dev->resource[2].start = 0x170; |
267 | { |
263 | dev->resource[2].end = 0x177; |
268 | dev->resource[2].start = 0x170; |
264 | dev->resource[2].flags = LEGACY_IO_RESOURCE; |
269 | dev->resource[2].end = 0x177; |
265 | dev->resource[3].start = 0x376; |
270 | dev->resource[2].flags = LEGACY_IO_RESOURCE; |
266 | dev->resource[3].end = 0x376; |
271 | dev->resource[3].start = 0x376; |
267 | dev->resource[3].flags = LEGACY_IO_RESOURCE; |
272 | dev->resource[3].end = 0x376; |
268 | }; |
273 | dev->resource[3].flags = LEGACY_IO_RESOURCE; |
269 | } |
274 | }; |
270 | break; |
275 | } |
271 | 276 | break; |
|
272 | case PCI_HEADER_TYPE_BRIDGE: /* bridge header */ |
277 | |
273 | if (class != PCI_CLASS_BRIDGE_PCI) |
278 | case PCI_HEADER_TYPE_BRIDGE: /* bridge header */ |
274 | goto bad; |
279 | if (class != PCI_CLASS_BRIDGE_PCI) |
275 | /* The PCI-to-PCI bridge spec requires that subtractive |
280 | goto bad; |
276 | decoding (i.e. transparent) bridge must have programming |
281 | /* The PCI-to-PCI bridge spec requires that subtractive |
277 | interface code of 0x01. */ |
282 | decoding (i.e. transparent) bridge must have programming |
278 | pci_read_irq(dev); |
283 | interface code of 0x01. */ |
279 | dev->transparent = ((dev->class & 0xff) == 1); |
284 | pci_read_irq(dev); |
280 | pci_read_bases(dev, 2, PCI_ROM_ADDRESS1); |
285 | dev->transparent = ((dev->class & 0xff) == 1); |
281 | break; |
286 | pci_read_bases(dev, 2, PCI_ROM_ADDRESS1); |
282 | 287 | break; |
|
283 | case PCI_HEADER_TYPE_CARDBUS: /* CardBus bridge header */ |
288 | |
284 | if (class != PCI_CLASS_BRIDGE_CARDBUS) |
289 | case PCI_HEADER_TYPE_CARDBUS: /* CardBus bridge header */ |
285 | goto bad; |
290 | if (class != PCI_CLASS_BRIDGE_CARDBUS) |
286 | pci_read_irq(dev); |
291 | goto bad; |
287 | pci_read_bases(dev, 1, 0); |
292 | pci_read_irq(dev); |
288 | dev->subsystem_vendor = PciRead16(dev->busnr, |
293 | pci_read_bases(dev, 1, 0); |
289 | dev->devfn, |
294 | dev->subsystem_vendor = PciRead16(dev->busnr, |
290 | PCI_CB_SUBSYSTEM_VENDOR_ID); |
295 | dev->devfn, |
291 | 296 | PCI_CB_SUBSYSTEM_VENDOR_ID); |
|
292 | dev->subsystem_device = PciRead16(dev->busnr, |
297 | |
293 | dev->devfn, |
298 | dev->subsystem_device = PciRead16(dev->busnr, |
294 | PCI_CB_SUBSYSTEM_ID); |
299 | dev->devfn, |
295 | break; |
300 | PCI_CB_SUBSYSTEM_ID); |
296 | 301 | break; |
|
297 | default: /* unknown header */ |
302 | |
298 | printk(KERN_ERR "PCI: device %s has unknown header type %02x, ignoring.\n", |
303 | default: /* unknown header */ |
299 | pci_name(dev), dev->hdr_type); |
304 | printk(KERN_ERR "PCI: device %s has unknown header type %02x, ignoring.\n", |
300 | return -1; |
305 | pci_name(dev), dev->hdr_type); |
301 | 306 | return -1; |
|
302 | bad: |
307 | |
303 | printk(KERN_ERR "PCI: %s: class %x doesn't match header type %02x. Ignoring class.\n", |
308 | bad: |
304 | pci_name(dev), class, dev->hdr_type); |
309 | printk(KERN_ERR "PCI: %s: class %x doesn't match header type %02x. Ignoring class.\n", |
305 | dev->class = PCI_CLASS_NOT_DEFINED; |
310 | pci_name(dev), class, dev->hdr_type); |
306 | } |
311 | dev->class = PCI_CLASS_NOT_DEFINED; |
307 | 312 | } |
|
308 | /* We found a fine healthy device, go go go... */ |
313 | |
309 | 314 | /* We found a fine healthy device, go go go... */ |
|
310 | return 0; |
315 | |
311 | }; |
316 | return 0; |
312 | 317 | }; |
|
313 | static pci_dev_t* pci_scan_device(u32 busnr, int devfn) |
318 | |
314 | { |
319 | static pci_dev_t* pci_scan_device(u32 busnr, int devfn) |
315 | pci_dev_t *dev; |
320 | { |
316 | 321 | pci_dev_t *dev; |
|
317 | u32 id; |
322 | |
318 | u8 hdr; |
323 | u32 id; |
319 | 324 | u8 hdr; |
|
320 | int timeout = 10; |
325 | |
321 | 326 | int timeout = 10; |
|
322 | id = PciRead32(busnr, devfn, PCI_VENDOR_ID); |
327 | |
323 | 328 | id = PciRead32(busnr, devfn, PCI_VENDOR_ID); |
|
324 | /* some broken boards return 0 or ~0 if a slot is empty: */ |
329 | |
325 | if (id == 0xffffffff || id == 0x00000000 || |
330 | /* some broken boards return 0 or ~0 if a slot is empty: */ |
326 | id == 0x0000ffff || id == 0xffff0000) |
331 | if (id == 0xffffffff || id == 0x00000000 || |
327 | return NULL; |
332 | id == 0x0000ffff || id == 0xffff0000) |
328 | 333 | return NULL; |
|
329 | while (id == 0xffff0001) |
334 | |
330 | { |
335 | while (id == 0xffff0001) |
331 | 336 | { |
|
332 | delay(timeout/10); |
337 | |
333 | timeout *= 2; |
338 | delay(timeout/10); |
334 | 339 | timeout *= 2; |
|
335 | id = PciRead32(busnr, devfn, PCI_VENDOR_ID); |
340 | |
336 | 341 | id = PciRead32(busnr, devfn, PCI_VENDOR_ID); |
|
337 | /* Card hasn't responded in 60 seconds? Must be stuck. */ |
342 | |
338 | if (timeout > 60 * 100) |
343 | /* Card hasn't responded in 60 seconds? Must be stuck. */ |
339 | { |
344 | if (timeout > 60 * 100) |
340 | printk(KERN_WARNING "Device %04x:%02x:%02x.%d not " |
345 | { |
341 | "responding\n", busnr,PCI_SLOT(devfn),PCI_FUNC(devfn)); |
346 | printk(KERN_WARNING "Device %04x:%02x:%02x.%d not " |
342 | return NULL; |
347 | "responding\n", busnr,PCI_SLOT(devfn),PCI_FUNC(devfn)); |
343 | } |
348 | return NULL; |
344 | }; |
349 | } |
345 | 350 | }; |
|
346 | if( pci_scan_filter(id, busnr, devfn) == 0) |
351 | |
347 | return NULL; |
352 | if( pci_scan_filter(id, busnr, devfn) == 0) |
348 | 353 | return NULL; |
|
349 | hdr = PciRead8(busnr, devfn, PCI_HEADER_TYPE); |
354 | |
350 | 355 | hdr = PciRead8(busnr, devfn, PCI_HEADER_TYPE); |
|
351 | dev = (pci_dev_t*)kzalloc(sizeof(pci_dev_t), 0); |
356 | |
352 | if(unlikely(dev == NULL)) |
357 | dev = (pci_dev_t*)kzalloc(sizeof(pci_dev_t), 0); |
353 | return NULL; |
358 | if(unlikely(dev == NULL)) |
354 | 359 | return NULL; |
|
355 | INIT_LIST_HEAD(&dev->link); |
360 | |
356 | 361 | INIT_LIST_HEAD(&dev->link); |
|
357 | 362 | ||
358 | dev->pci_dev.busnr = busnr; |
363 | |
359 | dev->pci_dev.devfn = devfn; |
364 | dev->pci_dev.busnr = busnr; |
360 | dev->pci_dev.hdr_type = hdr & 0x7f; |
365 | dev->pci_dev.devfn = devfn; |
361 | dev->pci_dev.multifunction = !!(hdr & 0x80); |
366 | dev->pci_dev.hdr_type = hdr & 0x7f; |
362 | dev->pci_dev.vendor = id & 0xffff; |
367 | dev->pci_dev.multifunction = !!(hdr & 0x80); |
363 | dev->pci_dev.device = (id >> 16) & 0xffff; |
368 | dev->pci_dev.vendor = id & 0xffff; |
364 | 369 | dev->pci_dev.device = (id >> 16) & 0xffff; |
|
365 | pci_setup_device(&dev->pci_dev); |
370 | |
366 | 371 | pci_setup_device(&dev->pci_dev); |
|
367 | return dev; |
372 | |
368 | 373 | return dev; |
|
369 | }; |
374 | |
370 | 375 | }; |
|
371 | 376 | ||
372 | 377 | ||
373 | 378 | ||
374 | int pci_scan_slot(u32 bus, int devfn) |
379 | |
375 | { |
380 | int _pci_scan_slot(u32 bus, int devfn) |
376 | int func, nr = 0; |
381 | { |
377 | 382 | int func, nr = 0; |
|
378 | for (func = 0; func < 8; func++, devfn++) |
383 | |
379 | { |
384 | for (func = 0; func < 8; func++, devfn++) |
380 | pci_dev_t *dev; |
385 | { |
381 | 386 | pci_dev_t *dev; |
|
382 | dev = pci_scan_device(bus, devfn); |
387 | |
383 | if( dev ) |
388 | dev = pci_scan_device(bus, devfn); |
384 | { |
389 | if( dev ) |
385 | list_add(&dev->link, &devices); |
390 | { |
386 | 391 | list_add(&dev->link, &devices); |
|
387 | nr++; |
392 | |
388 | 393 | nr++; |
|
389 | /* |
394 | |
390 | * If this is a single function device, |
395 | /* |
391 | * don't scan past the first function. |
396 | * If this is a single function device, |
392 | */ |
397 | * don't scan past the first function. |
393 | if (!dev->pci_dev.multifunction) |
398 | */ |
394 | { |
399 | if (!dev->pci_dev.multifunction) |
395 | if (func > 0) { |
400 | { |
396 | dev->pci_dev.multifunction = 1; |
401 | if (func > 0) { |
397 | } |
402 | dev->pci_dev.multifunction = 1; |
398 | else { |
403 | } |
399 | break; |
404 | else { |
400 | } |
405 | break; |
401 | } |
406 | } |
402 | } |
407 | } |
403 | else { |
408 | } |
404 | if (func == 0) |
409 | else { |
405 | break; |
410 | if (func == 0) |
406 | } |
411 | break; |
407 | }; |
412 | } |
408 | 413 | }; |
|
409 | return nr; |
414 | |
410 | }; |
415 | return nr; |
411 | 416 | }; |
|
412 | #define PCI_FIND_CAP_TTL 48 |
417 | |
413 | 418 | #define PCI_FIND_CAP_TTL 48 |
|
414 | static int __pci_find_next_cap_ttl(unsigned int bus, unsigned int devfn, |
419 | |
415 | u8 pos, int cap, int *ttl) |
420 | static int __pci_find_next_cap_ttl(unsigned int bus, unsigned int devfn, |
416 | { |
421 | u8 pos, int cap, int *ttl) |
417 | u8 id; |
422 | { |
418 | 423 | u8 id; |
|
419 | while ((*ttl)--) { |
424 | |
420 | pos = PciRead8(bus, devfn, pos); |
425 | while ((*ttl)--) { |
421 | if (pos < 0x40) |
426 | pos = PciRead8(bus, devfn, pos); |
422 | break; |
427 | if (pos < 0x40) |
423 | pos &= ~3; |
428 | break; |
424 | id = PciRead8(bus, devfn, pos + PCI_CAP_LIST_ID); |
429 | pos &= ~3; |
425 | if (id == 0xff) |
430 | id = PciRead8(bus, devfn, pos + PCI_CAP_LIST_ID); |
426 | break; |
431 | if (id == 0xff) |
427 | if (id == cap) |
432 | break; |
428 | return pos; |
433 | if (id == cap) |
429 | pos += PCI_CAP_LIST_NEXT; |
434 | return pos; |
430 | } |
435 | pos += PCI_CAP_LIST_NEXT; |
431 | return 0; |
436 | } |
432 | } |
437 | return 0; |
433 | 438 | } |
|
434 | static int __pci_find_next_cap(unsigned int bus, unsigned int devfn, |
439 | |
435 | u8 pos, int cap) |
440 | static int __pci_find_next_cap(unsigned int bus, unsigned int devfn, |
436 | { |
441 | u8 pos, int cap) |
437 | int ttl = PCI_FIND_CAP_TTL; |
442 | { |
438 | 443 | int ttl = PCI_FIND_CAP_TTL; |
|
439 | return __pci_find_next_cap_ttl(bus, devfn, pos, cap, &ttl); |
444 | |
440 | } |
445 | return __pci_find_next_cap_ttl(bus, devfn, pos, cap, &ttl); |
441 | 446 | } |
|
442 | static int __pci_bus_find_cap_start(unsigned int bus, |
447 | |
443 | unsigned int devfn, u8 hdr_type) |
448 | static int __pci_bus_find_cap_start(unsigned int bus, |
444 | { |
449 | unsigned int devfn, u8 hdr_type) |
445 | u16 status; |
450 | { |
446 | 451 | u16 status; |
|
447 | status = PciRead16(bus, devfn, PCI_STATUS); |
452 | |
448 | if (!(status & PCI_STATUS_CAP_LIST)) |
453 | status = PciRead16(bus, devfn, PCI_STATUS); |
449 | return 0; |
454 | if (!(status & PCI_STATUS_CAP_LIST)) |
450 | 455 | return 0; |
|
451 | switch (hdr_type) { |
456 | |
452 | case PCI_HEADER_TYPE_NORMAL: |
457 | switch (hdr_type) { |
453 | case PCI_HEADER_TYPE_BRIDGE: |
458 | case PCI_HEADER_TYPE_NORMAL: |
454 | return PCI_CAPABILITY_LIST; |
459 | case PCI_HEADER_TYPE_BRIDGE: |
455 | case PCI_HEADER_TYPE_CARDBUS: |
460 | return PCI_CAPABILITY_LIST; |
456 | return PCI_CB_CAPABILITY_LIST; |
461 | case PCI_HEADER_TYPE_CARDBUS: |
457 | default: |
462 | return PCI_CB_CAPABILITY_LIST; |
458 | return 0; |
463 | default: |
459 | } |
464 | return 0; |
460 | 465 | } |
|
461 | return 0; |
466 | |
462 | } |
467 | return 0; |
463 | 468 | } |
|
464 | 469 | ||
465 | int pci_find_capability(struct pci_dev *dev, int cap) |
470 | |
466 | { |
471 | int pci_find_capability(struct pci_dev *dev, int cap) |
467 | int pos; |
472 | { |
468 | 473 | int pos; |
|
469 | pos = __pci_bus_find_cap_start(dev->busnr, dev->devfn, dev->hdr_type); |
474 | |
470 | if (pos) |
475 | pos = __pci_bus_find_cap_start(dev->busnr, dev->devfn, dev->hdr_type); |
471 | pos = __pci_find_next_cap(dev->busnr, dev->devfn, pos, cap); |
476 | if (pos) |
472 | 477 | pos = __pci_find_next_cap(dev->busnr, dev->devfn, pos, cap); |
|
473 | return pos; |
478 | |
474 | } |
479 | return pos; |
475 | 480 | } |
|
476 | 481 | ||
477 | 482 | ||
478 | 483 | ||
479 | int enum_pci_devices() |
484 | |
480 | { |
485 | int enum_pci_devices() |
481 | pci_dev_t *dev; |
486 | { |
482 | u32 last_bus; |
487 | pci_dev_t *dev; |
483 | u32 bus = 0 , devfn = 0; |
488 | u32 last_bus; |
484 | 489 | u32 bus = 0 , devfn = 0; |
|
485 | 490 | ||
486 | last_bus = PciApi(1); |
491 | |
487 | 492 | last_bus = PciApi(1); |
|
488 | 493 | ||
489 | if( unlikely(last_bus == -1)) |
494 | |
490 | return -1; |
495 | if( unlikely(last_bus == -1)) |
491 | 496 | return -1; |
|
492 | for(;bus <= last_bus; bus++) |
497 | |
493 | { |
498 | for(;bus <= last_bus; bus++) |
494 | for (devfn = 0; devfn < 0x100; devfn += 8) |
499 | { |
495 | pci_scan_slot(bus, devfn); |
500 | for (devfn = 0; devfn < 0x100; devfn += 8) |
496 | 501 | _pci_scan_slot(bus, devfn); |
|
497 | 502 | ||
498 | } |
503 | |
499 | for(dev = (pci_dev_t*)devices.next; |
504 | } |
500 | &dev->link != &devices; |
505 | for(dev = (pci_dev_t*)devices.next; |
501 | dev = (pci_dev_t*)dev->link.next) |
506 | &dev->link != &devices; |
502 | { |
507 | dev = (pci_dev_t*)dev->link.next) |
503 | dbgprintf("PCI device %x:%x bus:%x devfn:%x\n", |
508 | { |
504 | dev->pci_dev.vendor, |
509 | dbgprintf("PCI device %x:%x bus:%x devfn:%x\n", |
505 | dev->pci_dev.device, |
510 | dev->pci_dev.vendor, |
506 | dev->pci_dev.busnr, |
511 | dev->pci_dev.device, |
507 | dev->pci_dev.devfn); |
512 | dev->pci_dev.busnr, |
508 | 513 | dev->pci_dev.devfn); |
|
509 | } |
514 | |
510 | return 0; |
515 | } |
511 | } |
516 | return 0; |
512 | 517 | } |
|
513 | const struct pci_device_id* find_pci_device(pci_dev_t* pdev, const struct pci_device_id *idlist) |
518 | |
514 | { |
519 | const struct pci_device_id* find_pci_device(pci_dev_t* pdev, const struct pci_device_id *idlist) |
515 | pci_dev_t *dev; |
520 | { |
516 | const struct pci_device_id *ent; |
521 | pci_dev_t *dev; |
517 | 522 | const struct pci_device_id *ent; |
|
518 | for(dev = (pci_dev_t*)devices.next; |
523 | |
519 | &dev->link != &devices; |
524 | for(dev = (pci_dev_t*)devices.next; |
520 | dev = (pci_dev_t*)dev->link.next) |
525 | &dev->link != &devices; |
521 | { |
526 | dev = (pci_dev_t*)dev->link.next) |
522 | if( dev->pci_dev.vendor != idlist->vendor ) |
527 | { |
523 | continue; |
528 | if( dev->pci_dev.vendor != idlist->vendor ) |
524 | 529 | continue; |
|
525 | for(ent = idlist; ent->vendor != 0; ent++) |
530 | |
526 | { |
531 | for(ent = idlist; ent->vendor != 0; ent++) |
527 | if(unlikely(ent->device == dev->pci_dev.device)) |
532 | { |
528 | { |
533 | if(unlikely(ent->device == dev->pci_dev.device)) |
529 | pdev->pci_dev = dev->pci_dev; |
534 | { |
530 | return ent; |
535 | pdev->pci_dev = dev->pci_dev; |
531 | } |
536 | return ent; |
532 | }; |
537 | } |
533 | } |
538 | }; |
534 | 539 | } |
|
535 | return NULL; |
540 | |
536 | }; |
541 | return NULL; |
537 | 542 | }; |
|
538 | struct pci_dev * |
543 | |
539 | pci_get_device(unsigned int vendor, unsigned int device, struct pci_dev *from) |
544 | struct pci_dev * |
540 | { |
545 | pci_get_device(unsigned int vendor, unsigned int device, struct pci_dev *from) |
541 | pci_dev_t *dev; |
546 | { |
542 | 547 | pci_dev_t *dev; |
|
543 | dev = (pci_dev_t*)devices.next; |
548 | |
544 | 549 | dev = (pci_dev_t*)devices.next; |
|
545 | if(from != NULL) |
550 | |
546 | { |
551 | if(from != NULL) |
547 | for(; &dev->link != &devices; |
552 | { |
548 | dev = (pci_dev_t*)dev->link.next) |
553 | for(; &dev->link != &devices; |
549 | { |
554 | dev = (pci_dev_t*)dev->link.next) |
550 | if( &dev->pci_dev == from) |
555 | { |
551 | { |
556 | if( &dev->pci_dev == from) |
552 | dev = (pci_dev_t*)dev->link.next; |
557 | { |
553 | break; |
558 | dev = (pci_dev_t*)dev->link.next; |
554 | }; |
559 | break; |
555 | } |
560 | }; |
556 | }; |
561 | } |
557 | 562 | }; |
|
558 | for(; &dev->link != &devices; |
563 | |
559 | dev = (pci_dev_t*)dev->link.next) |
564 | for(; &dev->link != &devices; |
560 | { |
565 | dev = (pci_dev_t*)dev->link.next) |
561 | if( dev->pci_dev.vendor != vendor ) |
566 | { |
562 | continue; |
567 | if( dev->pci_dev.vendor != vendor ) |
563 | 568 | continue; |
|
564 | if(dev->pci_dev.device == device) |
569 | |
565 | { |
570 | if(dev->pci_dev.device == device) |
566 | return &dev->pci_dev; |
571 | { |
567 | } |
572 | return &dev->pci_dev; |
568 | } |
573 | } |
569 | return NULL; |
574 | } |
570 | }; |
575 | return NULL; |
571 | 576 | }; |
|
572 | 577 | ||
573 | struct pci_dev * pci_get_bus_and_slot(unsigned int bus, unsigned int devfn) |
578 | |
574 | { |
579 | struct pci_dev * _pci_get_bus_and_slot(unsigned int bus, unsigned int devfn) |
575 | pci_dev_t *dev; |
580 | { |
576 | 581 | pci_dev_t *dev; |
|
577 | for(dev = (pci_dev_t*)devices.next; |
582 | |
578 | &dev->link != &devices; |
583 | for(dev = (pci_dev_t*)devices.next; |
579 | dev = (pci_dev_t*)dev->link.next) |
584 | &dev->link != &devices; |
580 | { |
585 | dev = (pci_dev_t*)dev->link.next) |
581 | if ( dev->pci_dev.busnr == bus && dev->pci_dev.devfn == devfn) |
586 | { |
582 | return &dev->pci_dev; |
587 | if ( dev->pci_dev.busnr == bus && dev->pci_dev.devfn == devfn) |
583 | } |
588 | return &dev->pci_dev; |
584 | return NULL; |
589 | } |
585 | } |
590 | return NULL; |
586 | 591 | } |
|
587 | struct pci_dev *pci_get_class(unsigned int class, struct pci_dev *from) |
592 | |
588 | { |
593 | struct pci_dev *pci_get_class(unsigned int class, struct pci_dev *from) |
589 | pci_dev_t *dev; |
594 | { |
590 | 595 | pci_dev_t *dev; |
|
591 | dev = (pci_dev_t*)devices.next; |
596 | |
592 | 597 | dev = (pci_dev_t*)devices.next; |
|
593 | if(from != NULL) |
598 | |
594 | { |
599 | if(from != NULL) |
595 | for(; &dev->link != &devices; |
600 | { |
596 | dev = (pci_dev_t*)dev->link.next) |
601 | for(; &dev->link != &devices; |
597 | { |
602 | dev = (pci_dev_t*)dev->link.next) |
598 | if( &dev->pci_dev == from) |
603 | { |
599 | { |
604 | if( &dev->pci_dev == from) |
600 | dev = (pci_dev_t*)dev->link.next; |
605 | { |
601 | break; |
606 | dev = (pci_dev_t*)dev->link.next; |
602 | }; |
607 | break; |
603 | } |
608 | }; |
604 | }; |
609 | } |
605 | 610 | }; |
|
606 | for(; &dev->link != &devices; |
611 | |
607 | dev = (pci_dev_t*)dev->link.next) |
612 | for(; &dev->link != &devices; |
608 | { |
613 | dev = (pci_dev_t*)dev->link.next) |
609 | if( dev->pci_dev.class == class) |
614 | { |
610 | { |
615 | if( dev->pci_dev.class == class) |
611 | return &dev->pci_dev; |
616 | { |
612 | } |
617 | return &dev->pci_dev; |
613 | } |
618 | } |
614 | 619 | } |
|
615 | return NULL; |
620 | |
616 | } |
621 | return NULL; |
617 | 622 | } |
|
618 | 623 | ||
619 | #define PIO_OFFSET 0x10000UL |
624 | |
620 | #define PIO_MASK 0x0ffffUL |
625 | #define PIO_OFFSET 0x10000UL |
621 | #define PIO_RESERVED 0x40000UL |
626 | #define PIO_MASK 0x0ffffUL |
622 | 627 | #define PIO_RESERVED 0x40000UL |
|
623 | #define IO_COND(addr, is_pio, is_mmio) do { \ |
628 | |
624 | unsigned long port = (unsigned long __force)addr; \ |
629 | #define IO_COND(addr, is_pio, is_mmio) do { \ |
625 | if (port >= PIO_RESERVED) { \ |
630 | unsigned long port = (unsigned long __force)addr; \ |
626 | is_mmio; \ |
631 | if (port >= PIO_RESERVED) { \ |
627 | } else if (port > PIO_OFFSET) { \ |
632 | is_mmio; \ |
628 | port &= PIO_MASK; \ |
633 | } else if (port > PIO_OFFSET) { \ |
629 | is_pio; \ |
634 | port &= PIO_MASK; \ |
630 | }; \ |
635 | is_pio; \ |
631 | } while (0) |
636 | }; \ |
632 | 637 | } while (0) |
|
633 | /* Create a virtual mapping cookie for an IO port range */ |
638 | |
634 | void __iomem *ioport_map(unsigned long port, unsigned int nr) |
639 | /* Create a virtual mapping cookie for an IO port range */ |
635 | { |
640 | void __iomem *ioport_map(unsigned long port, unsigned int nr) |
636 | if (port > PIO_MASK) |
641 | { |
637 | return NULL; |
642 | if (port > PIO_MASK) |
638 | return (void __iomem *) (unsigned long) (port + PIO_OFFSET); |
643 | return NULL; |
639 | } |
644 | return (void __iomem *) (unsigned long) (port + PIO_OFFSET); |
640 | 645 | } |
|
641 | void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long maxlen) |
646 | |
642 | { |
647 | void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long maxlen) |
643 | resource_size_t start = pci_resource_start(dev, bar); |
648 | { |
644 | resource_size_t len = pci_resource_len(dev, bar); |
649 | resource_size_t start = pci_resource_start(dev, bar); |
645 | unsigned long flags = pci_resource_flags(dev, bar); |
650 | resource_size_t len = pci_resource_len(dev, bar); |
646 | 651 | unsigned long flags = pci_resource_flags(dev, bar); |
|
647 | if (!len || !start) |
652 | |
648 | return NULL; |
653 | if (!len || !start) |
649 | if (maxlen && len > maxlen) |
654 | return NULL; |
650 | len = maxlen; |
655 | if (maxlen && len > maxlen) |
651 | if (flags & IORESOURCE_IO) |
656 | len = maxlen; |
652 | return ioport_map(start, len); |
657 | if (flags & IORESOURCE_IO) |
653 | if (flags & IORESOURCE_MEM) { |
658 | return ioport_map(start, len); |
654 | return ioremap(start, len); |
659 | if (flags & IORESOURCE_MEM) { |
655 | } |
660 | return ioremap(start, len); |
656 | /* What? */ |
661 | } |
657 | return NULL; |
662 | /* What? */ |
658 | } |
663 | return NULL; |
659 | 664 | } |
|
660 | void pci_iounmap(struct pci_dev *dev, void __iomem * addr) |
665 | |
661 | { |
666 | void pci_iounmap(struct pci_dev *dev, void __iomem * addr) |
662 | IO_COND(addr, /* nothing */, iounmap(addr)); |
667 | { |
663 | } |
668 | IO_COND(addr, /* nothing */, iounmap(addr)); |
664 | 669 | } |
|
665 | 670 | ||
666 | static inline void |
671 | |
667 | pcibios_resource_to_bus(struct pci_dev *dev, struct pci_bus_region *region, |
672 | static inline void |
668 | struct resource *res) |
673 | _pcibios_resource_to_bus(struct pci_dev *dev, struct pci_bus_region *region, |
669 | { |
674 | struct resource *res) |
670 | region->start = res->start; |
675 | { |
671 | region->end = res->end; |
676 | region->start = res->start; |
672 | } |
677 | region->end = res->end; |
673 | 678 | } |
|
674 | 679 | ||
675 | int pci_enable_rom(struct pci_dev *pdev) |
680 | |
676 | { |
681 | int pci_enable_rom(struct pci_dev *pdev) |
677 | struct resource *res = pdev->resource + PCI_ROM_RESOURCE; |
682 | { |
678 | struct pci_bus_region region; |
683 | struct resource *res = pdev->resource + PCI_ROM_RESOURCE; |
679 | u32 rom_addr; |
684 | struct pci_bus_region region; |
680 | 685 | u32 rom_addr; |
|
681 | if (!res->flags) |
686 | |
682 | return -1; |
687 | if (!res->flags) |
683 | 688 | return -1; |
|
684 | pcibios_resource_to_bus(pdev, ®ion, res); |
689 | |
685 | pci_read_config_dword(pdev, pdev->rom_base_reg, &rom_addr); |
690 | _pcibios_resource_to_bus(pdev, ®ion, res); |
686 | rom_addr &= ~PCI_ROM_ADDRESS_MASK; |
691 | pci_read_config_dword(pdev, pdev->rom_base_reg, &rom_addr); |
687 | rom_addr |= region.start | PCI_ROM_ADDRESS_ENABLE; |
692 | rom_addr &= ~PCI_ROM_ADDRESS_MASK; |
688 | pci_write_config_dword(pdev, pdev->rom_base_reg, rom_addr); |
693 | rom_addr |= region.start | PCI_ROM_ADDRESS_ENABLE; |
689 | return 0; |
694 | pci_write_config_dword(pdev, pdev->rom_base_reg, rom_addr); |
690 | } |
695 | return 0; |
691 | 696 | } |
|
692 | void pci_disable_rom(struct pci_dev *pdev) |
697 | |
693 | { |
698 | void pci_disable_rom(struct pci_dev *pdev) |
694 | u32 rom_addr; |
699 | { |
695 | pci_read_config_dword(pdev, pdev->rom_base_reg, &rom_addr); |
700 | u32 rom_addr; |
696 | rom_addr &= ~PCI_ROM_ADDRESS_ENABLE; |
701 | pci_read_config_dword(pdev, pdev->rom_base_reg, &rom_addr); |
697 | pci_write_config_dword(pdev, pdev->rom_base_reg, rom_addr); |
702 | rom_addr &= ~PCI_ROM_ADDRESS_ENABLE; |
698 | } |
703 | pci_write_config_dword(pdev, pdev->rom_base_reg, rom_addr); |
699 | 704 | } |
|
700 | /** |
705 | |
701 | * pci_get_rom_size - obtain the actual size of the ROM image |
706 | /** |
702 | * @pdev: target PCI device |
707 | * pci_get_rom_size - obtain the actual size of the ROM image |
703 | * @rom: kernel virtual pointer to image of ROM |
708 | * @pdev: target PCI device |
704 | * @size: size of PCI window |
709 | * @rom: kernel virtual pointer to image of ROM |
705 | * return: size of actual ROM image |
710 | * @size: size of PCI window |
706 | * |
711 | * return: size of actual ROM image |
707 | * Determine the actual length of the ROM image. |
712 | * |
708 | * The PCI window size could be much larger than the |
713 | * Determine the actual length of the ROM image. |
709 | * actual image size. |
714 | * The PCI window size could be much larger than the |
710 | */ |
715 | * actual image size. |
711 | size_t pci_get_rom_size(struct pci_dev *pdev, void __iomem *rom, size_t size) |
716 | */ |
712 | { |
717 | size_t pci_get_rom_size(struct pci_dev *pdev, void __iomem *rom, size_t size) |
713 | void __iomem *image; |
718 | { |
714 | int last_image; |
719 | void __iomem *image; |
715 | 720 | int last_image; |
|
716 | image = rom; |
721 | |
717 | do { |
722 | image = rom; |
718 | void __iomem *pds; |
723 | do { |
719 | /* Standard PCI ROMs start out with these bytes 55 AA */ |
724 | void __iomem *pds; |
720 | if (readb(image) != 0x55) { |
725 | /* Standard PCI ROMs start out with these bytes 55 AA */ |
721 | dev_err(&pdev->dev, "Invalid ROM contents\n"); |
726 | if (readb(image) != 0x55) { |
722 | break; |
727 | dev_err(&pdev->dev, "Invalid ROM contents\n"); |
723 | } |
728 | break; |
724 | if (readb(image + 1) != 0xAA) |
729 | } |
725 | break; |
730 | if (readb(image + 1) != 0xAA) |
726 | /* get the PCI data structure and check its signature */ |
731 | break; |
727 | pds = image + readw(image + 24); |
732 | /* get the PCI data structure and check its signature */ |
728 | if (readb(pds) != 'P') |
733 | pds = image + readw(image + 24); |
729 | break; |
734 | if (readb(pds) != 'P') |
730 | if (readb(pds + 1) != 'C') |
735 | break; |
731 | break; |
736 | if (readb(pds + 1) != 'C') |
732 | if (readb(pds + 2) != 'I') |
737 | break; |
733 | break; |
738 | if (readb(pds + 2) != 'I') |
734 | if (readb(pds + 3) != 'R') |
739 | break; |
735 | break; |
740 | if (readb(pds + 3) != 'R') |
736 | last_image = readb(pds + 21) & 0x80; |
741 | break; |
737 | /* this length is reliable */ |
742 | last_image = readb(pds + 21) & 0x80; |
738 | image += readw(pds + 16) * 512; |
743 | /* this length is reliable */ |
739 | } while (!last_image); |
744 | image += readw(pds + 16) * 512; |
740 | 745 | } while (!last_image); |
|
741 | /* never return a size larger than the PCI resource window */ |
746 | |
742 | /* there are known ROMs that get the size wrong */ |
747 | /* never return a size larger than the PCI resource window */ |
743 | return min((size_t)(image - rom), size); |
748 | /* there are known ROMs that get the size wrong */ |
744 | } |
749 | return min((size_t)(image - rom), size); |
745 | 750 | } |
|
746 | 751 | ||
747 | /** |
752 | |
748 | * pci_map_rom - map a PCI ROM to kernel space |
753 | /** |
749 | * @pdev: pointer to pci device struct |
754 | * pci_map_rom - map a PCI ROM to kernel space |
750 | * @size: pointer to receive size of pci window over ROM |
755 | * @pdev: pointer to pci device struct |
751 | * |
756 | * @size: pointer to receive size of pci window over ROM |
752 | * Return: kernel virtual pointer to image of ROM |
757 | * |
753 | * |
758 | * Return: kernel virtual pointer to image of ROM |
754 | * Map a PCI ROM into kernel space. If ROM is boot video ROM, |
759 | * |
755 | * the shadow BIOS copy will be returned instead of the |
760 | * Map a PCI ROM into kernel space. If ROM is boot video ROM, |
756 | * actual ROM. |
761 | * the shadow BIOS copy will be returned instead of the |
757 | */ |
762 | * actual ROM. |
758 | void __iomem *pci_map_rom(struct pci_dev *pdev, size_t *size) |
763 | */ |
759 | { |
764 | void __iomem *pci_map_rom(struct pci_dev *pdev, size_t *size) |
760 | struct resource *res = &pdev->resource[PCI_ROM_RESOURCE]; |
765 | { |
761 | loff_t start; |
766 | struct resource *res = &pdev->resource[PCI_ROM_RESOURCE]; |
762 | void __iomem *rom; |
767 | loff_t start; |
763 | 768 | void __iomem *rom; |
|
764 | /* |
769 | |
765 | * IORESOURCE_ROM_SHADOW set on x86, x86_64 and IA64 supports legacy |
770 | /* |
766 | * memory map if the VGA enable bit of the Bridge Control register is |
771 | * IORESOURCE_ROM_SHADOW set on x86, x86_64 and IA64 supports legacy |
767 | * set for embedded VGA. |
772 | * memory map if the VGA enable bit of the Bridge Control register is |
768 | */ |
773 | * set for embedded VGA. |
769 | if (res->flags & IORESOURCE_ROM_SHADOW) { |
774 | */ |
770 | /* primary video rom always starts here */ |
775 | if (res->flags & IORESOURCE_ROM_SHADOW) { |
771 | start = (loff_t)0xC0000; |
776 | /* primary video rom always starts here */ |
772 | *size = 0x20000; /* cover C000:0 through E000:0 */ |
777 | start = (loff_t)0xC0000; |
773 | } else { |
778 | *size = 0x20000; /* cover C000:0 through E000:0 */ |
774 | if (res->flags & |
779 | } else { |
775 | (IORESOURCE_ROM_COPY | IORESOURCE_ROM_BIOS_COPY)) { |
780 | if (res->flags & |
776 | *size = pci_resource_len(pdev, PCI_ROM_RESOURCE); |
781 | (IORESOURCE_ROM_COPY | IORESOURCE_ROM_BIOS_COPY)) { |
777 | return (void __iomem *)(unsigned long) |
782 | *size = pci_resource_len(pdev, PCI_ROM_RESOURCE); |
778 | pci_resource_start(pdev, PCI_ROM_RESOURCE); |
783 | return (void __iomem *)(unsigned long) |
779 | } else { |
784 | pci_resource_start(pdev, PCI_ROM_RESOURCE); |
780 | start = (loff_t)0xC0000; |
785 | } else { |
781 | *size = 0x20000; /* cover C000:0 through E000:0 */ |
786 | start = (loff_t)0xC0000; |
782 | 787 | *size = 0x20000; /* cover C000:0 through E000:0 */ |
|
783 | } |
788 | |
784 | } |
789 | } |
785 | 790 | } |
|
786 | rom = ioremap(start, *size); |
791 | |
787 | if (!rom) { |
792 | rom = ioremap(start, *size); |
788 | /* restore enable if ioremap fails */ |
793 | if (!rom) { |
789 | if (!(res->flags & (IORESOURCE_ROM_ENABLE | |
794 | /* restore enable if ioremap fails */ |
790 | IORESOURCE_ROM_SHADOW | |
795 | if (!(res->flags & (IORESOURCE_ROM_ENABLE | |
791 | IORESOURCE_ROM_COPY))) |
796 | IORESOURCE_ROM_SHADOW | |
792 | pci_disable_rom(pdev); |
797 | IORESOURCE_ROM_COPY))) |
793 | return NULL; |
798 | pci_disable_rom(pdev); |
794 | } |
799 | return NULL; |
795 | 800 | } |
|
796 | /* |
801 | |
797 | * Try to find the true size of the ROM since sometimes the PCI window |
802 | /* |
798 | * size is much larger than the actual size of the ROM. |
803 | * Try to find the true size of the ROM since sometimes the PCI window |
799 | * True size is important if the ROM is going to be copied. |
804 | * size is much larger than the actual size of the ROM. |
800 | */ |
805 | * True size is important if the ROM is going to be copied. |
801 | *size = pci_get_rom_size(pdev, rom, *size); |
806 | */ |
802 | return rom; |
807 | *size = pci_get_rom_size(pdev, rom, *size); |
803 | } |
808 | return rom; |
804 | 809 | } |
|
805 | void pci_unmap_rom(struct pci_dev *pdev, void __iomem *rom) |
810 | |
806 | { |
811 | void pci_unmap_rom(struct pci_dev *pdev, void __iomem *rom) |
807 | struct resource *res = &pdev->resource[PCI_ROM_RESOURCE]; |
812 | { |
808 | 813 | struct resource *res = &pdev->resource[PCI_ROM_RESOURCE]; |
|
809 | if (res->flags & (IORESOURCE_ROM_COPY | IORESOURCE_ROM_BIOS_COPY)) |
814 | |
810 | return; |
815 | if (res->flags & (IORESOURCE_ROM_COPY | IORESOURCE_ROM_BIOS_COPY)) |
811 | 816 | return; |
|
812 | iounmap(rom); |
817 | |
813 | 818 | iounmap(rom); |
|
814 | /* Disable again before continuing, leave enabled if pci=rom */ |
819 | |
815 | if (!(res->flags & (IORESOURCE_ROM_ENABLE | IORESOURCE_ROM_SHADOW))) |
820 | /* Disable again before continuing, leave enabled if pci=rom */ |
816 | pci_disable_rom(pdev); |
821 | if (!(res->flags & (IORESOURCE_ROM_ENABLE | IORESOURCE_ROM_SHADOW))) |
817 | } |
822 | pci_disable_rom(pdev); |
818 | 823 | } |
|
819 | static void __pci_set_master(struct pci_dev *dev, bool enable) |
824 | |
820 | { |
825 | static void __pci_set_master(struct pci_dev *dev, bool enable) |
821 | u16 old_cmd, cmd; |
826 | { |
822 | 827 | u16 old_cmd, cmd; |
|
823 | pci_read_config_word(dev, PCI_COMMAND, &old_cmd); |
828 | |
824 | if (enable) |
829 | pci_read_config_word(dev, PCI_COMMAND, &old_cmd); |
825 | cmd = old_cmd | PCI_COMMAND_MASTER; |
830 | if (enable) |
826 | else |
831 | cmd = old_cmd | PCI_COMMAND_MASTER; |
827 | cmd = old_cmd & ~PCI_COMMAND_MASTER; |
832 | else |
828 | if (cmd != old_cmd) { |
833 | cmd = old_cmd & ~PCI_COMMAND_MASTER; |
829 | dbgprintf("%s bus mastering\n", |
834 | if (cmd != old_cmd) { |
830 | enable ? "enabling" : "disabling"); |
835 | dbgprintf("%s bus mastering\n", |
831 | pci_write_config_word(dev, PCI_COMMAND, cmd); |
836 | enable ? "enabling" : "disabling"); |
832 | } |
837 | pci_write_config_word(dev, PCI_COMMAND, cmd); |
833 | dev->is_busmaster = enable; |
838 | } |
834 | } |
839 | dev->is_busmaster = enable; |
835 | 840 | } |
|
836 | 841 | ||
837 | /* pci_set_master - enables bus-mastering for device dev |
842 | |
838 | * @dev: the PCI device to enable |
843 | /* pci_set_master - enables bus-mastering for device dev |
839 | * |
844 | * @dev: the PCI device to enable |
840 | * Enables bus-mastering on the device and calls pcibios_set_master() |
845 | * |
841 | * to do the needed arch specific settings. |
846 | * Enables bus-mastering on the device and calls pcibios_set_master() |
842 | */ |
847 | * to do the needed arch specific settings. |
843 | void pci_set_master(struct pci_dev *dev) |
848 | */ |
844 | { |
849 | void pci_set_master(struct pci_dev *dev) |
845 | __pci_set_master(dev, true); |
850 | { |
846 | // pcibios_set_master(dev); |
851 | __pci_set_master(dev, true); |
847 | } |
852 | // pcibios_set_master(dev); |
848 | 853 | } |
|
849 | /** |
854 | |
850 | * pci_clear_master - disables bus-mastering for device dev |
855 | /** |
851 | * @dev: the PCI device to disable |
856 | * pci_clear_master - disables bus-mastering for device dev |
852 | */ |
857 | * @dev: the PCI device to disable |
853 | void pci_clear_master(struct pci_dev *dev) |
858 | */ |
854 | { |
859 | void pci_clear_master(struct pci_dev *dev) |
855 | __pci_set_master(dev, false); |
860 | { |
856 | } |
861 | __pci_set_master(dev, false); |
857 | 862 | } |
|
858 | 863 | ||
859 | static inline int pcie_cap_version(const struct pci_dev *dev) |
864 | |
860 | { |
865 | static inline int pcie_cap_version(const struct pci_dev *dev) |
861 | return dev->pcie_flags_reg & PCI_EXP_FLAGS_VERS; |
866 | { |
862 | } |
867 | return dev->pcie_flags_reg & PCI_EXP_FLAGS_VERS; |
863 | 868 | } |
|
864 | static inline bool pcie_cap_has_devctl(const struct pci_dev *dev) |
869 | |
865 | { |
870 | static inline bool pcie_cap_has_devctl(const struct pci_dev *dev) |
866 | return true; |
871 | { |
867 | } |
872 | return true; |
868 | 873 | } |
|
869 | static inline bool pcie_cap_has_lnkctl(const struct pci_dev *dev) |
874 | |
870 | { |
875 | static inline bool pcie_cap_has_lnkctl(const struct pci_dev *dev) |
871 | int type = pci_pcie_type(dev); |
876 | { |
872 | 877 | int type = pci_pcie_type(dev); |
|
873 | return pcie_cap_version(dev) > 1 || |
878 | |
874 | type == PCI_EXP_TYPE_ROOT_PORT || |
879 | return pcie_cap_version(dev) > 1 || |
875 | type == PCI_EXP_TYPE_ENDPOINT || |
880 | type == PCI_EXP_TYPE_ROOT_PORT || |
876 | type == PCI_EXP_TYPE_LEG_END; |
881 | type == PCI_EXP_TYPE_ENDPOINT || |
877 | } |
882 | type == PCI_EXP_TYPE_LEG_END; |
878 | 883 | } |
|
879 | static inline bool pcie_cap_has_sltctl(const struct pci_dev *dev) |
884 | |
880 | { |
885 | static inline bool pcie_cap_has_sltctl(const struct pci_dev *dev) |
881 | int type = pci_pcie_type(dev); |
886 | { |
882 | 887 | int type = pci_pcie_type(dev); |
|
883 | return pcie_cap_version(dev) > 1 || |
888 | |
884 | type == PCI_EXP_TYPE_ROOT_PORT || |
889 | return pcie_cap_version(dev) > 1 || |
885 | (type == PCI_EXP_TYPE_DOWNSTREAM && |
890 | type == PCI_EXP_TYPE_ROOT_PORT || |
886 | dev->pcie_flags_reg & PCI_EXP_FLAGS_SLOT); |
891 | (type == PCI_EXP_TYPE_DOWNSTREAM && |
887 | } |
892 | dev->pcie_flags_reg & PCI_EXP_FLAGS_SLOT); |
888 | 893 | } |
|
889 | static inline bool pcie_cap_has_rtctl(const struct pci_dev *dev) |
894 | |
890 | { |
895 | static inline bool pcie_cap_has_rtctl(const struct pci_dev *dev) |
891 | int type = pci_pcie_type(dev); |
896 | { |
892 | 897 | int type = pci_pcie_type(dev); |
|
893 | return pcie_cap_version(dev) > 1 || |
898 | |
894 | type == PCI_EXP_TYPE_ROOT_PORT || |
899 | return pcie_cap_version(dev) > 1 || |
895 | type == PCI_EXP_TYPE_RC_EC; |
900 | type == PCI_EXP_TYPE_ROOT_PORT || |
896 | } |
901 | type == PCI_EXP_TYPE_RC_EC; |
897 | 902 | } |
|
898 | static bool pcie_capability_reg_implemented(struct pci_dev *dev, int pos) |
903 | |
899 | { |
904 | static bool pcie_capability_reg_implemented(struct pci_dev *dev, int pos) |
900 | if (!pci_is_pcie(dev)) |
905 | { |
901 | return false; |
906 | if (!pci_is_pcie(dev)) |
902 | 907 | return false; |
|
903 | switch (pos) { |
908 | |
904 | case PCI_EXP_FLAGS_TYPE: |
909 | switch (pos) { |
905 | return true; |
910 | case PCI_EXP_FLAGS_TYPE: |
906 | case PCI_EXP_DEVCAP: |
911 | return true; |
907 | case PCI_EXP_DEVCTL: |
912 | case PCI_EXP_DEVCAP: |
908 | case PCI_EXP_DEVSTA: |
913 | case PCI_EXP_DEVCTL: |
909 | return pcie_cap_has_devctl(dev); |
914 | case PCI_EXP_DEVSTA: |
910 | case PCI_EXP_LNKCAP: |
915 | return pcie_cap_has_devctl(dev); |
911 | case PCI_EXP_LNKCTL: |
916 | case PCI_EXP_LNKCAP: |
912 | case PCI_EXP_LNKSTA: |
917 | case PCI_EXP_LNKCTL: |
913 | return pcie_cap_has_lnkctl(dev); |
918 | case PCI_EXP_LNKSTA: |
914 | case PCI_EXP_SLTCAP: |
919 | return pcie_cap_has_lnkctl(dev); |
915 | case PCI_EXP_SLTCTL: |
920 | case PCI_EXP_SLTCAP: |
916 | case PCI_EXP_SLTSTA: |
921 | case PCI_EXP_SLTCTL: |
917 | return pcie_cap_has_sltctl(dev); |
922 | case PCI_EXP_SLTSTA: |
918 | case PCI_EXP_RTCTL: |
923 | return pcie_cap_has_sltctl(dev); |
919 | case PCI_EXP_RTCAP: |
924 | case PCI_EXP_RTCTL: |
920 | case PCI_EXP_RTSTA: |
925 | case PCI_EXP_RTCAP: |
921 | return pcie_cap_has_rtctl(dev); |
926 | case PCI_EXP_RTSTA: |
922 | case PCI_EXP_DEVCAP2: |
927 | return pcie_cap_has_rtctl(dev); |
923 | case PCI_EXP_DEVCTL2: |
928 | case PCI_EXP_DEVCAP2: |
924 | case PCI_EXP_LNKCAP2: |
929 | case PCI_EXP_DEVCTL2: |
925 | case PCI_EXP_LNKCTL2: |
930 | case PCI_EXP_LNKCAP2: |
926 | case PCI_EXP_LNKSTA2: |
931 | case PCI_EXP_LNKCTL2: |
927 | return pcie_cap_version(dev) > 1; |
932 | case PCI_EXP_LNKSTA2: |
928 | default: |
933 | return pcie_cap_version(dev) > 1; |
929 | return false; |
934 | default: |
930 | } |
935 | return false; |
931 | } |
936 | } |
932 | 937 | } |
|
933 | /* |
938 | |
934 | * Note that these accessor functions are only for the "PCI Express |
939 | /* |
935 | * Capability" (see PCIe spec r3.0, sec 7.8). They do not apply to the |
940 | * Note that these accessor functions are only for the "PCI Express |
936 | * other "PCI Express Extended Capabilities" (AER, VC, ACS, MFVC, etc.) |
941 | * Capability" (see PCIe spec r3.0, sec 7.8). They do not apply to the |
937 | */ |
942 | * other "PCI Express Extended Capabilities" (AER, VC, ACS, MFVC, etc.) |
938 | int pcie_capability_read_word(struct pci_dev *dev, int pos, u16 *val) |
943 | */ |
939 | { |
944 | int pcie_capability_read_word(struct pci_dev *dev, int pos, u16 *val) |
940 | int ret; |
945 | { |
941 | 946 | int ret; |
|
942 | *val = 0; |
947 | |
943 | if (pos & 1) |
948 | *val = 0; |
944 | return -EINVAL; |
949 | if (pos & 1) |
945 | 950 | return -EINVAL; |
|
946 | if (pcie_capability_reg_implemented(dev, pos)) { |
951 | |
947 | ret = pci_read_config_word(dev, pci_pcie_cap(dev) + pos, val); |
952 | if (pcie_capability_reg_implemented(dev, pos)) { |
948 | /* |
953 | ret = pci_read_config_word(dev, pci_pcie_cap(dev) + pos, val); |
949 | * Reset *val to 0 if pci_read_config_word() fails, it may |
954 | /* |
950 | * have been written as 0xFFFF if hardware error happens |
955 | * Reset *val to 0 if pci_read_config_word() fails, it may |
951 | * during pci_read_config_word(). |
956 | * have been written as 0xFFFF if hardware error happens |
952 | */ |
957 | * during pci_read_config_word(). |
953 | if (ret) |
958 | */ |
954 | *val = 0; |
959 | if (ret) |
955 | return ret; |
960 | *val = 0; |
956 | } |
961 | return ret; |
957 | 962 | } |
|
958 | /* |
963 | |
959 | * For Functions that do not implement the Slot Capabilities, |
964 | /* |
960 | * Slot Status, and Slot Control registers, these spaces must |
965 | * For Functions that do not implement the Slot Capabilities, |
961 | * be hardwired to 0b, with the exception of the Presence Detect |
966 | * Slot Status, and Slot Control registers, these spaces must |
962 | * State bit in the Slot Status register of Downstream Ports, |
967 | * be hardwired to 0b, with the exception of the Presence Detect |
963 | * which must be hardwired to 1b. (PCIe Base Spec 3.0, sec 7.8) |
968 | * State bit in the Slot Status register of Downstream Ports, |
964 | */ |
969 | * which must be hardwired to 1b. (PCIe Base Spec 3.0, sec 7.8) |
965 | if (pci_is_pcie(dev) && pos == PCI_EXP_SLTSTA && |
970 | */ |
966 | pci_pcie_type(dev) == PCI_EXP_TYPE_DOWNSTREAM) { |
971 | if (pci_is_pcie(dev) && pos == PCI_EXP_SLTSTA && |
967 | *val = PCI_EXP_SLTSTA_PDS; |
972 | pci_pcie_type(dev) == PCI_EXP_TYPE_DOWNSTREAM) { |
968 | } |
973 | *val = PCI_EXP_SLTSTA_PDS; |
969 | 974 | } |
|
970 | return 0; |
975 | |
971 | } |
976 | return 0; |
972 | EXPORT_SYMBOL(pcie_capability_read_word); |
977 | } |
973 | 978 | EXPORT_SYMBOL(pcie_capability_read_word); |
|
974 | int pcie_capability_read_dword(struct pci_dev *dev, int pos, u32 *val) |
979 | |
975 | { |
980 | int pcie_capability_read_dword(struct pci_dev *dev, int pos, u32 *val) |
976 | int ret; |
981 | { |
977 | 982 | int ret; |
|
978 | *val = 0; |
983 | |
979 | if (pos & 3) |
984 | *val = 0; |
980 | return -EINVAL; |
985 | if (pos & 3) |
981 | 986 | return -EINVAL; |
|
982 | if (pcie_capability_reg_implemented(dev, pos)) { |
987 | |
983 | ret = pci_read_config_dword(dev, pci_pcie_cap(dev) + pos, val); |
988 | if (pcie_capability_reg_implemented(dev, pos)) { |
984 | /* |
989 | ret = pci_read_config_dword(dev, pci_pcie_cap(dev) + pos, val); |
985 | * Reset *val to 0 if pci_read_config_dword() fails, it may |
990 | /* |
986 | * have been written as 0xFFFFFFFF if hardware error happens |
991 | * Reset *val to 0 if pci_read_config_dword() fails, it may |
987 | * during pci_read_config_dword(). |
992 | * have been written as 0xFFFFFFFF if hardware error happens |
988 | */ |
993 | * during pci_read_config_dword(). |
989 | if (ret) |
994 | */ |
990 | *val = 0; |
995 | if (ret) |
991 | return ret; |
996 | *val = 0; |
992 | } |
997 | return ret; |
993 | 998 | } |
|
994 | if (pci_is_pcie(dev) && pos == PCI_EXP_SLTCTL && |
999 | |
995 | pci_pcie_type(dev) == PCI_EXP_TYPE_DOWNSTREAM) { |
1000 | if (pci_is_pcie(dev) && pos == PCI_EXP_SLTCTL && |
996 | *val = PCI_EXP_SLTSTA_PDS; |
1001 | pci_pcie_type(dev) == PCI_EXP_TYPE_DOWNSTREAM) { |
997 | } |
1002 | *val = PCI_EXP_SLTSTA_PDS; |
998 | 1003 | } |
|
999 | return 0; |
1004 | |
1000 | } |
1005 | return 0; |
1001 | EXPORT_SYMBOL(pcie_capability_read_dword); |
1006 | } |
1002 | 1007 | EXPORT_SYMBOL(pcie_capability_read_dword); |
|
1003 | int pcie_capability_write_word(struct pci_dev *dev, int pos, u16 val) |
1008 | |
1004 | { |
1009 | int pcie_capability_write_word(struct pci_dev *dev, int pos, u16 val) |
1005 | if (pos & 1) |
1010 | { |
1006 | return -EINVAL; |
1011 | if (pos & 1) |
1007 | 1012 | return -EINVAL; |
|
1008 | if (!pcie_capability_reg_implemented(dev, pos)) |
1013 | |
1009 | return 0; |
1014 | if (!pcie_capability_reg_implemented(dev, pos)) |
1010 | 1015 | return 0; |
|
1011 | return pci_write_config_word(dev, pci_pcie_cap(dev) + pos, val); |
1016 | |
1012 | } |
1017 | return pci_write_config_word(dev, pci_pcie_cap(dev) + pos, val); |
1013 | EXPORT_SYMBOL(pcie_capability_write_word); |
1018 | } |
1014 | 1019 | EXPORT_SYMBOL(pcie_capability_write_word); |
|
1015 | int pcie_capability_write_dword(struct pci_dev *dev, int pos, u32 val) |
1020 | |
1016 | { |
1021 | int pcie_capability_write_dword(struct pci_dev *dev, int pos, u32 val) |
1017 | if (pos & 3) |
1022 | { |
1018 | return -EINVAL; |
1023 | if (pos & 3) |
1019 | 1024 | return -EINVAL; |
|
1020 | if (!pcie_capability_reg_implemented(dev, pos)) |
1025 | |
1021 | return 0; |
1026 | if (!pcie_capability_reg_implemented(dev, pos)) |
1022 | 1027 | return 0; |
|
1023 | return pci_write_config_dword(dev, pci_pcie_cap(dev) + pos, val); |
1028 | |
1024 | } |
1029 | return pci_write_config_dword(dev, pci_pcie_cap(dev) + pos, val); |
1025 | EXPORT_SYMBOL(pcie_capability_write_dword); |
1030 | } |
1026 | 1031 | EXPORT_SYMBOL(pcie_capability_write_dword); |
|
1027 | int pcie_capability_clear_and_set_word(struct pci_dev *dev, int pos, |
1032 | |
1028 | u16 clear, u16 set) |
1033 | int pcie_capability_clear_and_set_word(struct pci_dev *dev, int pos, |
1029 | { |
1034 | u16 clear, u16 set) |
1030 | int ret; |
1035 | { |
1031 | u16 val; |
1036 | int ret; |
1032 | 1037 | u16 val; |
|
1033 | ret = pcie_capability_read_word(dev, pos, &val); |
1038 | |
1034 | if (!ret) { |
1039 | ret = pcie_capability_read_word(dev, pos, &val); |
1035 | val &= ~clear; |
1040 | if (!ret) { |
1036 | val |= set; |
1041 | val &= ~clear; |
1037 | ret = pcie_capability_write_word(dev, pos, val); |
1042 | val |= set; |
1038 | } |
1043 | ret = pcie_capability_write_word(dev, pos, val); |
1039 | 1044 | } |
|
1040 | return ret; |
1045 | |
1041 | } |
1046 | return ret; |
1042 | 1047 | } |
|
1043 | 1048 | ||
1044 | 1049 | ||
1045 | int pcie_get_readrq(struct pci_dev *dev) |
1050 | |
1046 | { |
1051 | int pcie_get_readrq(struct pci_dev *dev) |
1047 | u16 ctl; |
1052 | { |
1048 | 1053 | u16 ctl; |
|
1049 | pcie_capability_read_word(dev, PCI_EXP_DEVCTL, &ctl); |
1054 | |
1050 | 1055 | pcie_capability_read_word(dev, PCI_EXP_DEVCTL, &ctl); |
|
1051 | return 128 << ((ctl & PCI_EXP_DEVCTL_READRQ) >> 12); |
1056 | |
1052 | } |
1057 | return 128 << ((ctl & PCI_EXP_DEVCTL_READRQ) >> 12); |
1053 | EXPORT_SYMBOL(pcie_get_readrq); |
1058 | } |
1054 | 1059 | EXPORT_SYMBOL(pcie_get_readrq); |
|
1055 | /** |
1060 | |
1056 | * pcie_set_readrq - set PCI Express maximum memory read request |
1061 | /** |
1057 | * @dev: PCI device to query |
1062 | * pcie_set_readrq - set PCI Express maximum memory read request |
1058 | * @rq: maximum memory read count in bytes |
1063 | * @dev: PCI device to query |
1059 | * valid values are 128, 256, 512, 1024, 2048, 4096 |
1064 | * @rq: maximum memory read count in bytes |
1060 | * |
1065 | * valid values are 128, 256, 512, 1024, 2048, 4096 |
1061 | * If possible sets maximum memory read request in bytes |
1066 | * |
1062 | */ |
1067 | * If possible sets maximum memory read request in bytes |
1063 | int pcie_set_readrq(struct pci_dev *dev, int rq) |
1068 | */ |
1064 | { |
1069 | int pcie_set_readrq(struct pci_dev *dev, int rq) |
1065 | u16 v; |
1070 | { |
1066 | 1071 | u16 v; |
|
1067 | if (rq < 128 || rq > 4096 || !is_power_of_2(rq)) |
1072 | |
1068 | return -EINVAL; |
1073 | if (rq < 128 || rq > 4096 || !is_power_of_2(rq)) |
1069 | 1074 | return -EINVAL; |
|
1070 | v = (ffs(rq) - 8) << 12; |
1075 | |
1071 | 1076 | v = (ffs(rq) - 8) << 12; |
|
1072 | return pcie_capability_clear_and_set_word(dev, PCI_EXP_DEVCTL, |
1077 | |
1073 | PCI_EXP_DEVCTL_READRQ, v); |
1078 | return pcie_capability_clear_and_set_word(dev, PCI_EXP_DEVCTL, |
1074 | }><>>><>>=>>>><>><>><>>4)><4)> |
1079 | PCI_EXP_DEVCTL_READRQ, v); |
- | 1080 | }><>>><>>=>>>><>><>><>>4)><4)> |