Rev 1302 | Rev 1787 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed
Rev 1302 | Rev 1324 | ||
---|---|---|---|
1 | /* |
1 | /* |
2 | * The PCI Library -- ID to Name Translation |
2 | * The PCI Library -- ID to Name Translation |
3 | * |
3 | * |
4 | * Copyright (c) 1997--2005 Martin Mares <mj@ucw.cz> |
4 | * Copyright (c) 1997--2005 Martin Mares <mj@ucw.cz> |
5 | * |
5 | * |
6 | * Modified and ported to HelenOS by Jakub Jermar. |
6 | * May 8, 2006 - Modified and ported to HelenOS by Jakub Jermar. |
7 | * |
7 | * |
8 | * Can be freely distributed and used under the terms of the GNU GPL. |
8 | * Can be freely distributed and used under the terms of the GNU GPL. |
9 | */ |
9 | */ |
10 | 10 | ||
11 | #include <stdio.h> |
11 | #include <stdio.h> |
12 | #include <stdlib.h> |
12 | #include <stdlib.h> |
13 | #include <stdarg.h> |
13 | #include <stdarg.h> |
14 | #include <string.h> |
14 | #include <string.h> |
15 | #include <errno.h> |
15 | #include <errno.h> |
16 | 16 | ||
17 | #include "internal.h" |
17 | #include "internal.h" |
18 | #include "pci_ids.h" |
18 | #include "pci_ids.h" |
19 | 19 | ||
20 | struct id_entry { |
20 | struct id_entry { |
21 | struct id_entry *next; |
21 | struct id_entry *next; |
22 | u32 id12, id34; |
22 | u32 id12, id34; |
23 | byte cat; |
23 | byte cat; |
24 | byte name[1]; |
24 | byte name[1]; |
25 | }; |
25 | }; |
26 | 26 | ||
27 | enum id_entry_type { |
27 | enum id_entry_type { |
28 | ID_UNKNOWN, |
28 | ID_UNKNOWN, |
29 | ID_VENDOR, |
29 | ID_VENDOR, |
30 | ID_DEVICE, |
30 | ID_DEVICE, |
31 | ID_SUBSYSTEM, |
31 | ID_SUBSYSTEM, |
32 | ID_GEN_SUBSYSTEM, |
32 | ID_GEN_SUBSYSTEM, |
33 | ID_CLASS, |
33 | ID_CLASS, |
34 | ID_SUBCLASS, |
34 | ID_SUBCLASS, |
35 | ID_PROGIF |
35 | ID_PROGIF |
36 | }; |
36 | }; |
37 | 37 | ||
38 | struct id_bucket { |
38 | struct id_bucket { |
39 | struct id_bucket *next; |
39 | struct id_bucket *next; |
40 | unsigned int full; |
40 | unsigned int full; |
41 | }; |
41 | }; |
42 | 42 | ||
43 | #define MAX_LINE 1024 |
43 | #define MAX_LINE 1024 |
44 | #define BUCKET_SIZE 8192 |
44 | #define BUCKET_SIZE 8192 |
45 | #define HASH_SIZE 4099 |
45 | #define HASH_SIZE 4099 |
46 | 46 | ||
47 | #ifdef __GNUC__ |
47 | #ifdef __GNUC__ |
48 | #define BUCKET_ALIGNMENT __alignof__(struct id_bucket) |
48 | #define BUCKET_ALIGNMENT __alignof__(struct id_bucket) |
49 | #else |
49 | #else |
50 | union id_align { |
50 | union id_align { |
51 | struct id_bucket *next; |
51 | struct id_bucket *next; |
52 | unsigned int full; |
52 | unsigned int full; |
53 | }; |
53 | }; |
54 | #define BUCKET_ALIGNMENT sizeof(union id_align) |
54 | #define BUCKET_ALIGNMENT sizeof(union id_align) |
55 | #endif |
55 | #endif |
56 | #define BUCKET_ALIGN(n) ((n)+BUCKET_ALIGNMENT-(n)%BUCKET_ALIGNMENT) |
56 | #define BUCKET_ALIGN(n) ((n)+BUCKET_ALIGNMENT-(n)%BUCKET_ALIGNMENT) |
57 | 57 | ||
58 | static void *id_alloc(struct pci_access *a, unsigned int size) |
58 | static void *id_alloc(struct pci_access *a, unsigned int size) |
59 | { |
59 | { |
60 | struct id_bucket *buck = a->current_id_bucket; |
60 | struct id_bucket *buck = a->current_id_bucket; |
61 | unsigned int pos; |
61 | unsigned int pos; |
62 | if (!buck || buck->full + size > BUCKET_SIZE) { |
62 | if (!buck || buck->full + size > BUCKET_SIZE) { |
63 | buck = pci_malloc(a, BUCKET_SIZE); |
63 | buck = pci_malloc(a, BUCKET_SIZE); |
64 | buck->next = a->current_id_bucket; |
64 | buck->next = a->current_id_bucket; |
65 | a->current_id_bucket = buck; |
65 | a->current_id_bucket = buck; |
66 | buck->full = BUCKET_ALIGN(sizeof(struct id_bucket)); |
66 | buck->full = BUCKET_ALIGN(sizeof(struct id_bucket)); |
67 | } |
67 | } |
68 | pos = buck->full; |
68 | pos = buck->full; |
69 | buck->full = BUCKET_ALIGN(buck->full + size); |
69 | buck->full = BUCKET_ALIGN(buck->full + size); |
70 | return (byte *) buck + pos; |
70 | return (byte *) buck + pos; |
71 | } |
71 | } |
72 | 72 | ||
73 | static inline u32 id_pair(unsigned int x, unsigned int y) |
73 | static inline u32 id_pair(unsigned int x, unsigned int y) |
74 | { |
74 | { |
75 | return ((x << 16) | y); |
75 | return ((x << 16) | y); |
76 | } |
76 | } |
77 | 77 | ||
78 | static inline unsigned int id_hash(int cat, u32 id12, u32 id34) |
78 | static inline unsigned int id_hash(int cat, u32 id12, u32 id34) |
79 | { |
79 | { |
80 | unsigned int h; |
80 | unsigned int h; |
81 | 81 | ||
82 | h = id12 ^ (id34 << 3) ^ (cat << 5); |
82 | h = id12 ^ (id34 << 3) ^ (cat << 5); |
83 | return h % HASH_SIZE; |
83 | return h % HASH_SIZE; |
84 | } |
84 | } |
85 | 85 | ||
86 | static struct id_entry *id_lookup(struct pci_access *a, int cat, int id1, |
86 | static struct id_entry *id_lookup(struct pci_access *a, int cat, int id1, |
87 | int id2, int id3, int id4) |
87 | int id2, int id3, int id4) |
88 | { |
88 | { |
89 | struct id_entry *n; |
89 | struct id_entry *n; |
90 | u32 id12 = id_pair(id1, id2); |
90 | u32 id12 = id_pair(id1, id2); |
91 | u32 id34 = id_pair(id3, id4); |
91 | u32 id34 = id_pair(id3, id4); |
92 | 92 | ||
93 | n = a->id_hash[id_hash(cat, id12, id34)]; |
93 | n = a->id_hash[id_hash(cat, id12, id34)]; |
94 | while (n && (n->id12 != id12 || n->id34 != id34 || n->cat != cat)) |
94 | while (n && (n->id12 != id12 || n->id34 != id34 || n->cat != cat)) |
95 | n = n->next; |
95 | n = n->next; |
96 | return n; |
96 | return n; |
97 | } |
97 | } |
98 | 98 | ||
99 | static int id_insert(struct pci_access *a, int cat, int id1, int id2, |
99 | static int id_insert(struct pci_access *a, int cat, int id1, int id2, |
100 | int id3, int id4, byte * text) |
100 | int id3, int id4, byte * text) |
101 | { |
101 | { |
102 | u32 id12 = id_pair(id1, id2); |
102 | u32 id12 = id_pair(id1, id2); |
103 | u32 id34 = id_pair(id3, id4); |
103 | u32 id34 = id_pair(id3, id4); |
104 | unsigned int h = id_hash(cat, id12, id34); |
104 | unsigned int h = id_hash(cat, id12, id34); |
105 | struct id_entry *n = a->id_hash[h]; |
105 | struct id_entry *n = a->id_hash[h]; |
106 | int len = strlen((char *) text); |
106 | int len = strlen((char *) text); |
107 | 107 | ||
108 | while (n && (n->id12 != id12 || n->id34 != id34 || n->cat != cat)) |
108 | while (n && (n->id12 != id12 || n->id34 != id34 || n->cat != cat)) |
109 | n = n->next; |
109 | n = n->next; |
110 | if (n) |
110 | if (n) |
111 | return 1; |
111 | return 1; |
112 | n = id_alloc(a, sizeof(struct id_entry) + len); |
112 | n = id_alloc(a, sizeof(struct id_entry) + len); |
113 | n->id12 = id12; |
113 | n->id12 = id12; |
114 | n->id34 = id34; |
114 | n->id34 = id34; |
115 | n->cat = cat; |
115 | n->cat = cat; |
116 | memcpy(n->name, text, len + 1); |
116 | memcpy(n->name, text, len + 1); |
117 | n->next = a->id_hash[h]; |
117 | n->next = a->id_hash[h]; |
118 | a->id_hash[h] = n; |
118 | a->id_hash[h] = n; |
119 | return 0; |
119 | return 0; |
120 | } |
120 | } |
121 | 121 | ||
122 | static int id_hex(byte * p, int cnt) |
122 | static int id_hex(byte * p, int cnt) |
123 | { |
123 | { |
124 | int x = 0; |
124 | int x = 0; |
125 | while (cnt--) { |
125 | while (cnt--) { |
126 | x <<= 4; |
126 | x <<= 4; |
127 | if (*p >= '0' && *p <= '9') |
127 | if (*p >= '0' && *p <= '9') |
128 | x += (*p - '0'); |
128 | x += (*p - '0'); |
129 | else if (*p >= 'a' && *p <= 'f') |
129 | else if (*p >= 'a' && *p <= 'f') |
130 | x += (*p - 'a' + 10); |
130 | x += (*p - 'a' + 10); |
131 | else if (*p >= 'A' && *p <= 'F') |
131 | else if (*p >= 'A' && *p <= 'F') |
132 | x += (*p - 'A' + 10); |
132 | x += (*p - 'A' + 10); |
133 | else |
133 | else |
134 | return -1; |
134 | return -1; |
135 | p++; |
135 | p++; |
136 | } |
136 | } |
137 | return x; |
137 | return x; |
138 | } |
138 | } |
139 | 139 | ||
140 | static inline int id_white_p(int c) |
140 | static inline int id_white_p(int c) |
141 | { |
141 | { |
142 | return (c == ' ') || (c == '\t'); |
142 | return (c == ' ') || (c == '\t'); |
143 | } |
143 | } |
144 | 144 | ||
145 | static const char *id_parse_list(struct pci_access *a, int *lino) |
145 | static const char *id_parse_list(struct pci_access *a, int *lino) |
146 | { |
146 | { |
147 | byte *line; |
147 | byte *line; |
148 | byte *p; |
148 | byte *p; |
149 | int id1 = 0, id2 = 0, id3 = 0, id4 = 0; |
149 | int id1 = 0, id2 = 0, id3 = 0, id4 = 0; |
150 | int cat = -1; |
150 | int cat = -1; |
151 | int nest; |
151 | int nest; |
152 | static const char parse_error[] = "Parse error"; |
152 | static const char parse_error[] = "Parse error"; |
153 | int i; |
153 | int i; |
154 | 154 | ||
155 | *lino = 0; |
155 | *lino = 0; |
156 | for (i = 0; i < sizeof(pci_ids) / sizeof(char *); i++) { |
156 | for (i = 0; i < sizeof(pci_ids) / sizeof(char *); i++) { |
157 | line = (byte *) pci_ids[i]; |
157 | line = (byte *) pci_ids[i]; |
158 | (*lino)++; |
158 | (*lino)++; |
159 | p = line; |
159 | p = line; |
160 | while (*p) |
160 | while (*p) |
161 | p++; |
161 | p++; |
162 | if (p > line && (p[-1] == ' ' || p[-1] == '\t')) |
162 | if (p > line && (p[-1] == ' ' || p[-1] == '\t')) |
163 | *--p = 0; |
163 | *--p = 0; |
164 | 164 | ||
165 | p = line; |
165 | p = line; |
166 | while (id_white_p(*p)) |
166 | while (id_white_p(*p)) |
167 | p++; |
167 | p++; |
168 | if (!*p || *p == '#') |
168 | if (!*p || *p == '#') |
169 | continue; |
169 | continue; |
170 | 170 | ||
171 | p = line; |
171 | p = line; |
172 | while (*p == '\t') |
172 | while (*p == '\t') |
173 | p++; |
173 | p++; |
174 | nest = p - line; |
174 | nest = p - line; |
175 | 175 | ||
176 | if (!nest) { /* Top-level entries */ |
176 | if (!nest) { /* Top-level entries */ |
177 | if (p[0] == 'C' && p[1] == ' ') { /* Class block */ |
177 | if (p[0] == 'C' && p[1] == ' ') { /* Class block */ |
178 | if ((id1 = id_hex(p + 2, 2)) < 0 |
178 | if ((id1 = id_hex(p + 2, 2)) < 0 || !id_white_p(p[4])) |
179 | || !id_white_p(p[4])) |
- | |
180 | return parse_error; |
179 | return parse_error; |
181 | cat = ID_CLASS; |
180 | cat = ID_CLASS; |
182 | p += 5; |
181 | p += 5; |
183 | } else if (p[0] == 'S' && p[1] == ' ') { /* Generic subsystem block */ |
182 | } else if (p[0] == 'S' && p[1] == ' ') { /* Generic subsystem block */ |
184 | if ((id1 = id_hex(p + 2, 4)) < 0 || p[6]) |
183 | if ((id1 = id_hex(p + 2, 4)) < 0 || p[6]) |
185 | return parse_error; |
184 | return parse_error; |
186 | if (!id_lookup(a, ID_VENDOR, id1, 0, 0, 0)) |
185 | if (!id_lookup(a, ID_VENDOR, id1, 0, 0, 0)) |
187 | return "Vendor does not exist"; |
186 | return "Vendor does not exist"; |
188 | cat = ID_GEN_SUBSYSTEM; |
187 | cat = ID_GEN_SUBSYSTEM; |
189 | continue; |
188 | continue; |
190 | } else if (p[0] >= 'A' && p[0] <= 'Z' && p[1] == ' ') { /* Unrecognized block (RFU) */ |
189 | } else if (p[0] >= 'A' && p[0] <= 'Z' && p[1] == ' ') { /* Unrecognized block (RFU) */ |
191 | cat = ID_UNKNOWN; |
190 | cat = ID_UNKNOWN; |
192 | continue; |
191 | continue; |
193 | } else { /* Vendor ID */ |
192 | } else { /* Vendor ID */ |
194 | 193 | ||
195 | if ((id1 = id_hex(p, 4)) < 0 |
194 | if ((id1 = id_hex(p, 4)) < 0 || !id_white_p(p[4])) |
196 | || !id_white_p(p[4])) |
- | |
197 | return parse_error; |
195 | return parse_error; |
198 | cat = ID_VENDOR; |
196 | cat = ID_VENDOR; |
199 | p += 5; |
197 | p += 5; |
200 | } |
198 | } |
201 | id2 = id3 = id4 = 0; |
199 | id2 = id3 = id4 = 0; |
202 | } else if (cat == ID_UNKNOWN) /* Nested entries in RFU blocks are skipped */ |
200 | } else if (cat == ID_UNKNOWN) /* Nested entries in RFU blocks are skipped */ |
203 | continue; |
201 | continue; |
204 | else if (nest == 1) /* Nesting level 1 */ |
202 | else if (nest == 1) /* Nesting level 1 */ |
205 | switch (cat) { |
203 | switch (cat) { |
206 | case ID_VENDOR: |
204 | case ID_VENDOR: |
207 | case ID_DEVICE: |
205 | case ID_DEVICE: |
208 | case ID_SUBSYSTEM: |
206 | case ID_SUBSYSTEM: |
209 | if ((id2 = id_hex(p, 4)) < 0 |
207 | if ((id2 = id_hex(p, 4)) < 0 || !id_white_p(p[4])) |
210 | || !id_white_p(p[4])) |
- | |
211 | return parse_error; |
208 | return parse_error; |
212 | p += 5; |
209 | p += 5; |
213 | cat = ID_DEVICE; |
210 | cat = ID_DEVICE; |
214 | id3 = id4 = 0; |
211 | id3 = id4 = 0; |
215 | break; |
212 | break; |
216 | case ID_GEN_SUBSYSTEM: |
213 | case ID_GEN_SUBSYSTEM: |
217 | if ((id2 = id_hex(p, 4)) < 0 |
214 | if ((id2 = id_hex(p, 4)) < 0 || !id_white_p(p[4])) |
218 | || !id_white_p(p[4])) |
- | |
219 | return parse_error; |
215 | return parse_error; |
220 | p += 5; |
216 | p += 5; |
221 | id3 = id4 = 0; |
217 | id3 = id4 = 0; |
222 | break; |
218 | break; |
223 | case ID_CLASS: |
219 | case ID_CLASS: |
224 | case ID_SUBCLASS: |
220 | case ID_SUBCLASS: |
225 | case ID_PROGIF: |
221 | case ID_PROGIF: |
226 | if ((id2 = id_hex(p, 2)) < 0 |
222 | if ((id2 = id_hex(p, 2)) < 0 || !id_white_p(p[2])) |
227 | || !id_white_p(p[2])) |
- | |
228 | return parse_error; |
223 | return parse_error; |
229 | p += 3; |
224 | p += 3; |
230 | cat = ID_SUBCLASS; |
225 | cat = ID_SUBCLASS; |
231 | id3 = id4 = 0; |
226 | id3 = id4 = 0; |
232 | break; |
227 | break; |
233 | default: |
228 | default: |
234 | return parse_error; |
229 | return parse_error; |
235 | } else if (nest == 2) /* Nesting level 2 */ |
230 | } else if (nest == 2) /* Nesting level 2 */ |
236 | switch (cat) { |
231 | switch (cat) { |
237 | case ID_DEVICE: |
232 | case ID_DEVICE: |
238 | case ID_SUBSYSTEM: |
233 | case ID_SUBSYSTEM: |
239 | if ((id3 = id_hex(p, 4)) < 0 |
234 | if ((id3 = id_hex(p, 4)) < 0 || !id_white_p(p[4]) |
240 | || !id_white_p(p[4]) |
- | |
241 | || (id4 = id_hex(p + 5, 4)) < 0 |
235 | || (id4 = id_hex(p + 5, 4)) < 0 || !id_white_p(p[9])) |
242 | || !id_white_p(p[9])) |
- | |
243 | return parse_error; |
236 | return parse_error; |
244 | p += 10; |
237 | p += 10; |
245 | cat = ID_SUBSYSTEM; |
238 | cat = ID_SUBSYSTEM; |
246 | break; |
239 | break; |
247 | case ID_CLASS: |
240 | case ID_CLASS: |
248 | case ID_SUBCLASS: |
241 | case ID_SUBCLASS: |
249 | case ID_PROGIF: |
242 | case ID_PROGIF: |
250 | if ((id3 = id_hex(p, 2)) < 0 |
243 | if ((id3 = id_hex(p, 2)) < 0 || !id_white_p(p[2])) |
251 | || !id_white_p(p[2])) |
- | |
252 | return parse_error; |
244 | return parse_error; |
253 | p += 3; |
245 | p += 3; |
254 | cat = ID_PROGIF; |
246 | cat = ID_PROGIF; |
255 | id4 = 0; |
247 | id4 = 0; |
256 | break; |
248 | break; |
257 | default: |
249 | default: |
258 | return parse_error; |
250 | return parse_error; |
259 | } else /* Nesting level 3 or more */ |
251 | } else /* Nesting level 3 or more */ |
260 | return parse_error; |
252 | return parse_error; |
261 | while (id_white_p(*p)) |
253 | while (id_white_p(*p)) |
262 | p++; |
254 | p++; |
263 | if (!*p) |
255 | if (!*p) |
264 | return parse_error; |
256 | return parse_error; |
265 | if (id_insert(a, cat, id1, id2, id3, id4, p)) |
257 | if (id_insert(a, cat, id1, id2, id3, id4, p)) |
266 | return "Duplicate entry"; |
258 | return "Duplicate entry"; |
267 | } |
259 | } |
268 | return NULL; |
260 | return NULL; |
269 | } |
261 | } |
270 | 262 | ||
271 | int pci_load_name_list(struct pci_access *a) |
263 | int pci_load_name_list(struct pci_access *a) |
272 | { |
264 | { |
273 | int lino; |
265 | int lino; |
274 | const char *err; |
266 | const char *err; |
275 | 267 | ||
276 | pci_free_name_list(a); |
268 | pci_free_name_list(a); |
277 | a->id_hash = pci_malloc(a, sizeof(struct id_entry *) * HASH_SIZE); |
269 | a->id_hash = pci_malloc(a, sizeof(struct id_entry *) * HASH_SIZE); |
278 | bzero(a->id_hash, sizeof(struct id_entry *) * HASH_SIZE); |
270 | bzero(a->id_hash, sizeof(struct id_entry *) * HASH_SIZE); |
279 | err = id_parse_list(a, &lino); |
271 | err = id_parse_list(a, &lino); |
280 | if (err) |
272 | if (err) |
281 | a->error("%s at %s, element %d\n", err, "pci_ids.h", lino); |
273 | a->error("%s at %s, element %d\n", err, "pci_ids.h", lino); |
282 | return 1; |
274 | return 1; |
283 | } |
275 | } |
284 | 276 | ||
285 | void pci_free_name_list(struct pci_access *a) |
277 | void pci_free_name_list(struct pci_access *a) |
286 | { |
278 | { |
287 | pci_mfree(a->id_hash); |
279 | pci_mfree(a->id_hash); |
288 | a->id_hash = NULL; |
280 | a->id_hash = NULL; |
289 | while (a->current_id_bucket) { |
281 | while (a->current_id_bucket) { |
290 | struct id_bucket *buck = a->current_id_bucket; |
282 | struct id_bucket *buck = a->current_id_bucket; |
291 | a->current_id_bucket = buck->next; |
283 | a->current_id_bucket = buck->next; |
292 | pci_mfree(buck); |
284 | pci_mfree(buck); |
293 | } |
285 | } |
294 | } |
286 | } |
295 | 287 | ||
296 | static struct id_entry *id_lookup_subsys(struct pci_access *a, int iv, |
288 | static struct id_entry *id_lookup_subsys(struct pci_access *a, int iv, |
297 | int id, int isv, int isd) |
289 | int id, int isv, int isd) |
298 | { |
290 | { |
299 | struct id_entry *d = NULL; |
291 | struct id_entry *d = NULL; |
300 | if (iv > 0 && id > 0) /* Per-device lookup */ |
292 | if (iv > 0 && id > 0) /* Per-device lookup */ |
301 | d = id_lookup(a, ID_SUBSYSTEM, iv, id, isv, isd); |
293 | d = id_lookup(a, ID_SUBSYSTEM, iv, id, isv, isd); |
302 | if (!d) /* Generic lookup */ |
294 | if (!d) /* Generic lookup */ |
303 | d = id_lookup(a, ID_GEN_SUBSYSTEM, isv, isd, 0, 0); |
295 | d = id_lookup(a, ID_GEN_SUBSYSTEM, isv, isd, 0, 0); |
304 | if (!d && iv == isv && id == isd) /* Check for subsystem == device */ |
296 | if (!d && iv == isv && id == isd) /* Check for subsystem == device */ |
305 | d = id_lookup(a, ID_DEVICE, iv, id, 0, 0); |
297 | d = id_lookup(a, ID_DEVICE, iv, id, 0, 0); |
306 | return d; |
298 | return d; |
307 | } |
299 | } |
308 | 300 | ||
309 | char *pci_lookup_name(struct pci_access *a, char *buf, int size, int flags, |
301 | char *pci_lookup_name(struct pci_access *a, char *buf, int size, int flags, |
310 | ...) |
302 | ...) |
311 | { |
303 | { |
312 | va_list args; |
304 | va_list args; |
313 | int num, res, synth; |
305 | int num, res, synth; |
314 | struct id_entry *v, *d, *cls, *pif; |
306 | struct id_entry *v, *d, *cls, *pif; |
315 | int iv, id, isv, isd, icls, ipif; |
307 | int iv, id, isv, isd, icls, ipif; |
316 | 308 | ||
317 | va_start(args, flags); |
309 | va_start(args, flags); |
318 | 310 | ||
319 | num = 0; |
311 | num = 0; |
320 | if ((flags & PCI_LOOKUP_NUMERIC) || a->numeric_ids) { |
312 | if ((flags & PCI_LOOKUP_NUMERIC) || a->numeric_ids) { |
321 | flags &= ~PCI_LOOKUP_NUMERIC; |
313 | flags &= ~PCI_LOOKUP_NUMERIC; |
322 | num = 1; |
314 | num = 1; |
323 | } else if (!a->id_hash) { |
315 | } else if (!a->id_hash) { |
324 | if (!pci_load_name_list(a)) |
316 | if (!pci_load_name_list(a)) |
325 | num = a->numeric_ids = 1; |
317 | num = a->numeric_ids = 1; |
326 | } |
318 | } |
327 | 319 | ||
328 | if (flags & PCI_LOOKUP_NO_NUMBERS) { |
320 | if (flags & PCI_LOOKUP_NO_NUMBERS) { |
329 | flags &= ~PCI_LOOKUP_NO_NUMBERS; |
321 | flags &= ~PCI_LOOKUP_NO_NUMBERS; |
330 | synth = 0; |
322 | synth = 0; |
331 | if (num) |
323 | if (num) |
332 | return NULL; |
324 | return NULL; |
333 | } else |
325 | } else |
334 | synth = 1; |
326 | synth = 1; |
335 | 327 | ||
336 | switch (flags) { |
328 | switch (flags) { |
337 | case PCI_LOOKUP_VENDOR: |
329 | case PCI_LOOKUP_VENDOR: |
338 | iv = va_arg(args, int); |
330 | iv = va_arg(args, int); |
339 | if (num) |
331 | if (num) |
340 | res = snprintf(buf, size, "%04x", iv); |
332 | res = snprintf(buf, size, "%04x", iv); |
341 | else if (v = id_lookup(a, ID_VENDOR, iv, 0, 0, 0)) |
333 | else if (v = id_lookup(a, ID_VENDOR, iv, 0, 0, 0)) |
342 | return (char *) v->name; |
334 | return (char *) v->name; |
343 | else |
335 | else |
344 | res = |
- | |
345 | snprintf(buf, size, "Unknown vendor %04x", iv); |
336 | res = snprintf(buf, size, "Unknown vendor %04x", iv); |
346 | break; |
337 | break; |
347 | case PCI_LOOKUP_DEVICE: |
338 | case PCI_LOOKUP_DEVICE: |
348 | iv = va_arg(args, int); |
339 | iv = va_arg(args, int); |
349 | id = va_arg(args, int); |
340 | id = va_arg(args, int); |
350 | if (num) |
341 | if (num) |
351 | res = snprintf(buf, size, "%04x", id); |
342 | res = snprintf(buf, size, "%04x", id); |
352 | else if (d = id_lookup(a, ID_DEVICE, iv, id, 0, 0)) |
343 | else if (d = id_lookup(a, ID_DEVICE, iv, id, 0, 0)) |
353 | return (char *) d->name; |
344 | return (char *) d->name; |
354 | else if (synth) |
345 | else if (synth) |
355 | res = |
- | |
356 | snprintf(buf, size, "Unknown device %04x", id); |
346 | res = snprintf(buf, size, "Unknown device %04x", id); |
357 | else |
347 | else |
358 | return NULL; |
348 | return NULL; |
359 | break; |
349 | break; |
360 | case PCI_LOOKUP_VENDOR | PCI_LOOKUP_DEVICE: |
350 | case PCI_LOOKUP_VENDOR | PCI_LOOKUP_DEVICE: |
361 | iv = va_arg(args, int); |
351 | iv = va_arg(args, int); |
362 | id = va_arg(args, int); |
352 | id = va_arg(args, int); |
363 | if (num) |
353 | if (num) |
364 | res = snprintf(buf, size, "%04x:%04x", iv, id); |
354 | res = snprintf(buf, size, "%04x:%04x", iv, id); |
365 | else { |
355 | else { |
366 | v = id_lookup(a, ID_VENDOR, iv, 0, 0, 0); |
356 | v = id_lookup(a, ID_VENDOR, iv, 0, 0, 0); |
367 | d = id_lookup(a, ID_DEVICE, iv, id, 0, 0); |
357 | d = id_lookup(a, ID_DEVICE, iv, id, 0, 0); |
368 | if (v && d) |
358 | if (v && d) |
369 | res = |
- | |
370 | snprintf(buf, size, "%s %s", v->name, |
359 | res = snprintf(buf, size, "%s %s", v->name, |
371 | d->name); |
360 | d->name); |
372 | else if (!synth) |
361 | else if (!synth) |
373 | return NULL; |
362 | return NULL; |
374 | else if (!v) |
363 | else if (!v) |
375 | res = |
- | |
376 | snprintf(buf, size, |
- | |
377 | "Unknown device %04x:%04x", |
364 | res = snprintf(buf, size, "Unknown device %04x:%04x", iv, id); |
378 | iv, id); |
- | |
379 | else /* !d */ |
365 | else /* !d */ |
380 | res = |
- | |
381 | snprintf(buf, size, |
- | |
382 | "%s Unknown device %04x", |
366 | res = snprintf(buf, size, "%s Unknown device %04x", v->name, id); |
383 | v->name, id); |
- | |
384 | } |
367 | } |
385 | break; |
368 | break; |
386 | case PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_VENDOR: |
369 | case PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_VENDOR: |
387 | isv = va_arg(args, int); |
370 | isv = va_arg(args, int); |
388 | if (num) |
371 | if (num) |
389 | res = snprintf(buf, size, "%04x", isv); |
372 | res = snprintf(buf, size, "%04x", isv); |
390 | else if (v = id_lookup(a, ID_VENDOR, isv, 0, 0, 0)) |
373 | else if (v = id_lookup(a, ID_VENDOR, isv, 0, 0, 0)) |
391 | return (char *) v->name; |
374 | return (char *) v->name; |
392 | else if (synth) |
375 | else if (synth) |
393 | res = |
- | |
394 | snprintf(buf, size, "Unknown vendor %04x", |
376 | res = snprintf(buf, size, "Unknown vendor %04x", isv); |
395 | isv); |
- | |
396 | else |
377 | else |
397 | return NULL; |
378 | return NULL; |
398 | break; |
379 | break; |
399 | case PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_DEVICE: |
380 | case PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_DEVICE: |
400 | iv = va_arg(args, int); |
381 | iv = va_arg(args, int); |
401 | id = va_arg(args, int); |
382 | id = va_arg(args, int); |
402 | isv = va_arg(args, int); |
383 | isv = va_arg(args, int); |
403 | isd = va_arg(args, int); |
384 | isd = va_arg(args, int); |
404 | if (num) |
385 | if (num) |
405 | res = snprintf(buf, size, "%04x", isd); |
386 | res = snprintf(buf, size, "%04x", isd); |
406 | else if (d = id_lookup_subsys(a, iv, id, isv, isd)) |
387 | else if (d = id_lookup_subsys(a, iv, id, isv, isd)) |
407 | return (char *) d->name; |
388 | return (char *) d->name; |
408 | else if (synth) |
389 | else if (synth) |
409 | res = |
- | |
410 | snprintf(buf, size, "Unknown device %04x", |
390 | res = snprintf(buf, size, "Unknown device %04x", isd); |
411 | isd); |
- | |
412 | else |
391 | else |
413 | return NULL; |
392 | return NULL; |
414 | break; |
393 | break; |
415 | case PCI_LOOKUP_VENDOR | PCI_LOOKUP_DEVICE | PCI_LOOKUP_SUBSYSTEM: |
394 | case PCI_LOOKUP_VENDOR | PCI_LOOKUP_DEVICE | PCI_LOOKUP_SUBSYSTEM: |
416 | iv = va_arg(args, int); |
395 | iv = va_arg(args, int); |
417 | id = va_arg(args, int); |
396 | id = va_arg(args, int); |
418 | isv = va_arg(args, int); |
397 | isv = va_arg(args, int); |
419 | isd = va_arg(args, int); |
398 | isd = va_arg(args, int); |
420 | if (num) |
399 | if (num) |
421 | res = snprintf(buf, size, "%04x:%04x", isv, isd); |
400 | res = snprintf(buf, size, "%04x:%04x", isv, isd); |
422 | else { |
401 | else { |
423 | v = id_lookup(a, ID_VENDOR, isv, 0, 0, 0); |
402 | v = id_lookup(a, ID_VENDOR, isv, 0, 0, 0); |
424 | d = id_lookup_subsys(a, iv, id, isv, isd); |
403 | d = id_lookup_subsys(a, iv, id, isv, isd); |
425 | if (v && d) |
404 | if (v && d) |
426 | res = |
- | |
427 | snprintf(buf, size, "%s %s", v->name, |
405 | res = snprintf(buf, size, "%s %s", v->name, d->name); |
428 | d->name); |
- | |
429 | else if (!synth) |
406 | else if (!synth) |
430 | return NULL; |
407 | return NULL; |
431 | else if (!v) |
408 | else if (!v) |
432 | res = |
- | |
433 | snprintf(buf, size, |
- | |
434 | "Unknown device %04x:%04x", |
409 | res = snprintf(buf, size, "Unknown device %04x:%04x", isv, isd); |
435 | isv, isd); |
- | |
436 | else /* !d */ |
410 | else /* !d */ |
437 | res = |
- | |
438 | snprintf(buf, size, |
- | |
439 | "%s Unknown device %04x", |
411 | res = snprintf(buf, size, "%s Unknown device %04x", v->name, isd); |
440 | v->name, isd); |
- | |
441 | } |
412 | } |
442 | break; |
413 | break; |
443 | case PCI_LOOKUP_CLASS: |
414 | case PCI_LOOKUP_CLASS: |
444 | icls = va_arg(args, int); |
415 | icls = va_arg(args, int); |
445 | if (num) |
416 | if (num) |
446 | res = snprintf(buf, size, "%04x", icls); |
417 | res = snprintf(buf, size, "%04x", icls); |
447 | else if (cls = |
- | |
448 | id_lookup(a, ID_SUBCLASS, icls >> 8, icls & 0xff, |
418 | else if (cls = id_lookup(a, ID_SUBCLASS, icls >> 8, icls & 0xff, 0, 0)) |
449 | 0, 0)) |
- | |
450 | return (char *) cls->name; |
419 | return (char *) cls->name; |
451 | else if (cls = id_lookup(a, ID_CLASS, icls, 0, 0, 0)) |
420 | else if (cls = id_lookup(a, ID_CLASS, icls, 0, 0, 0)) |
452 | res = |
- | |
453 | snprintf(buf, size, "%s [%04x]", cls->name, |
421 | res = snprintf(buf, size, "%s [%04x]", cls->name, icls); |
454 | icls); |
- | |
455 | else if (synth) |
422 | else if (synth) |
456 | res = snprintf(buf, size, "Class %04x", icls); |
423 | res = snprintf(buf, size, "Class %04x", icls); |
457 | else |
424 | else |
458 | return NULL; |
425 | return NULL; |
459 | break; |
426 | break; |
460 | case PCI_LOOKUP_PROGIF: |
427 | case PCI_LOOKUP_PROGIF: |
461 | icls = va_arg(args, int); |
428 | icls = va_arg(args, int); |
462 | ipif = va_arg(args, int); |
429 | ipif = va_arg(args, int); |
463 | if (num) |
430 | if (num) |
464 | res = snprintf(buf, size, "%02x", ipif); |
431 | res = snprintf(buf, size, "%02x", ipif); |
465 | else if (pif = |
- | |
466 | id_lookup(a, ID_PROGIF, icls >> 8, icls & 0xff, |
432 | else if (pif = id_lookup(a, ID_PROGIF, icls >> 8, icls & 0xff, ipif, 0)) |
467 | ipif, 0)) |
- | |
468 | return (char *) pif->name; |
433 | return (char *) pif->name; |
469 | else if (icls == 0x0101 && !(ipif & 0x70)) { |
434 | else if (icls == 0x0101 && !(ipif & 0x70)) { |
470 | /* IDE controllers have complex prog-if semantics */ |
435 | /* IDE controllers have complex prog-if semantics */ |
471 | res = snprintf(buf, size, "%s%s%s%s%s", |
436 | res = snprintf(buf, size, "%s%s%s%s%s", |
472 | (ipif & 0x80) ? "Master " : "", |
437 | (ipif & 0x80) ? "Master " : "", |
473 | (ipif & 0x08) ? "SecP " : "", |
438 | (ipif & 0x08) ? "SecP " : "", |
474 | (ipif & 0x04) ? "SecO " : "", |
439 | (ipif & 0x04) ? "SecO " : "", |
475 | (ipif & 0x02) ? "PriP " : "", |
440 | (ipif & 0x02) ? "PriP " : "", |
476 | (ipif & 0x01) ? "PriO " : ""); |
441 | (ipif & 0x01) ? "PriO " : ""); |
477 | if (res > 0 && res < size) |
442 | if (res > 0 && res < size) |
478 | buf[--res] = 0; |
443 | buf[--res] = 0; |
479 | } else if (synth) |
444 | } else if (synth) |
480 | res = snprintf(buf, size, "ProgIf %02x", ipif); |
445 | res = snprintf(buf, size, "ProgIf %02x", ipif); |
481 | else |
446 | else |
482 | return NULL; |
447 | return NULL; |
483 | break; |
448 | break; |
484 | default: |
449 | default: |
485 | return "<pci_lookup_name: invalid request>"; |
450 | return "<pci_lookup_name: invalid request>"; |
486 | } |
451 | } |
487 | if (res < 0 || res >= size) |
452 | if (res < 0 || res >= size) |
488 | return "<pci_lookup_name: buffer too small>"; |
453 | return "<pci_lookup_name: buffer too small>"; |
489 | else |
454 | else |
490 | return buf; |
455 | return buf; |
491 | } |
456 | } |
492 | 457 |