?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
doc: fix sgml errors
[mit.git] / tables.c
blobc8629209e74a3ec770212762d7a5a68702e57a07
1 #include <string.h>
2 #include <stdio.h>
3 #include <stdlib.h>
4 #include <ctype.h>
5 #include "depmod.h"
6 #include "tables.h"
7 #include "util.h"
8
9 /* Turn /lib/modules/2.5.49/kernel/foo.ko(.gz) => foo */
10 static void make_shortname(char *dest, const char *src)
11 {
12 char *ext;
13 const char *bname;
14
15 bname = my_basename(src);
16 strcpy(dest, bname);
17 ext = strchr(dest, '.');
18 if (ext)
19 *ext = '\0';
20 }
21
22 /* We set driver_data to zero */
23 static void output_pci_entry(struct pci_device_id *pci, char *name, FILE *out,
24 int conv)
25 {
26 fprintf(out,
27 "%-20s 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x0\n",
28 name,
29 END(pci->vendor, conv),
30 END(pci->device, conv),
31 END(pci->subvendor, conv),
32 END(pci->subdevice, conv),
33 END(pci->class, conv),
34 END(pci->class_mask, conv));
35 }
36
37 int output_pci_table(struct module *modules, FILE *out, char *dirname)
38 {
39 struct module *i;
40
41 fprintf(out, "# pci module vendor device subvendor"
42 " subdevice class class_mask driver_data\n");
43
44 for (i = modules; i; i = i->next) {
45 struct pci_device_id *e;
46 char shortname[strlen(i->pathname) + 1];
47 struct module_tables *t = &i->tables;
48
49 if (!t->pci_table)
50 continue;
51
52 make_shortname(shortname, i->pathname);
53 for (e = t->pci_table; e->vendor; e = (void *)e + t->pci_size)
54 output_pci_entry(e, shortname, out, i->file->conv);
55 }
56 return 1;
57 }
58
59 /* We set driver_info to zero */
60 static void output_usb_entry(struct usb_device_id *usb, char *name, FILE *out,
61 int conv)
62 {
63 fprintf(out, "%-20s 0x%04x 0x%04x 0x%04x 0x%04x"
64 " 0x%04x 0x%02x 0x%02x"
65 " 0x%02x 0x%02x"
66 " 0x%02x 0x%02x"
67 " 0x0\n",
68 name,
69 END(usb->match_flags, conv),
70 END(usb->idVendor, conv),
71 END(usb->idProduct, conv),
72 END(usb->bcdDevice_lo, conv),
73 END(usb->bcdDevice_hi, conv),
74 END(usb->bDeviceClass, conv),
75 END(usb->bDeviceSubClass, conv),
76 END(usb->bDeviceProtocol, conv),
77 END(usb->bInterfaceClass, conv),
78 END(usb->bInterfaceSubClass, conv),
79 END(usb->bInterfaceProtocol, conv));
80 }
81
82 int output_usb_table(struct module *modules, FILE *out, char *dirname)
83 {
84 struct module *i;
85
86 fprintf(out, "# usb module ");
87 /* Requires all users to be on kernel 2.4.0 or later */
88 fprintf(out, "match_flags ");
89 fprintf(out, "idVendor idProduct bcdDevice_lo bcdDevice_hi"
90 " bDeviceClass bDeviceSubClass bDeviceProtocol"
91 " bInterfaceClass bInterfaceSubClass"
92 " bInterfaceProtocol driver_info\n");
93
94 for (i = modules; i; i = i->next) {
95 struct usb_device_id *e;
96 char shortname[strlen(i->pathname) + 1];
97 struct module_tables *t = &i->tables;
98
99 if (!t->usb_table)
100 continue;
101
102 make_shortname(shortname, i->pathname);
103 for (e = t->usb_table;
104 e->idVendor || e->bDeviceClass || e->bInterfaceClass;
105 e = (void *)e + t->usb_size)
106 output_usb_entry(e, shortname, out, i->file->conv);
107 }
108 return 1;
109 }
110
111 static void output_ieee1394_entry(struct ieee1394_device_id *fw, char *name,
112 FILE *out, int conv)
113 {
114 fprintf(out, "%-20s 0x%08x 0x%06x 0x%06x 0x%06x 0x%06x\n",
115 name,
116 END(fw->match_flags, conv),
117 END(fw->vendor_id, conv),
118 END(fw->model_id, conv),
119 END(fw->specifier_id, conv),
120 END(fw->version, conv));
121 }
122
123 int output_ieee1394_table(struct module *modules, FILE *out, char *dirname)
124 {
125 struct module *i;
126
127 fprintf(out, "# ieee1394 module ");
128 fprintf(out, "match_flags vendor_id model_id specifier_id version\n");
129
130 for (i = modules; i; i = i->next) {
131 struct ieee1394_device_id *fw;
132 char shortname[strlen(i->pathname) + 1];
133 struct module_tables *t = &i->tables;
134
135 if (!t->ieee1394_table)
136 continue;
137
138 make_shortname(shortname, i->pathname);
139 for (fw = t->ieee1394_table; fw->match_flags;
140 fw = (void *) fw + t->ieee1394_size)
141 output_ieee1394_entry(fw, shortname, out, i->file->conv);
142 }
143 return 1;
144 }
145
146
147 /* We set driver_data to zero */
148 static void output_ccw_entry(struct ccw_device_id *ccw, char *name, FILE *out,
149 int conv)
150 {
151 fprintf(out, "%-20s 0x%04x 0x%04x 0x%02x 0x%04x 0x%02x\n",
152 name, END(ccw->match_flags, conv),
153 END(ccw->cu_type, conv), END(ccw->cu_model, conv),
154 END(ccw->dev_type, conv), END(ccw->dev_model, conv));
155 }
156
157 int output_ccw_table(struct module *modules, FILE *out, char *dirname)
158 {
159 struct module *i;
160
161 fprintf(out, "# ccw module ");
162 fprintf(out, "match_flags cu_type cu_model dev_type dev_model\n");
163
164 for (i = modules; i; i = i->next) {
165 struct ccw_device_id *e;
166 char shortname[strlen(i->pathname) + 1];
167 struct module_tables *t = &i->tables;
168
169 if (!t->ccw_table)
170 continue;
171
172 make_shortname(shortname, i->pathname);
173 for (e = t->ccw_table;
174 e->cu_type || e->cu_model || e->dev_type || e->dev_model;
175 e = (void *) e + t->ccw_size)
176 output_ccw_entry(e, shortname, out, i->file->conv);
177 }
178 return 1;
179 }
180
181 #define ISAPNP_VENDOR(a,b,c) (((((a)-'A'+1)&0x3f)<<2)|\
182 ((((b)-'A'+1)&0x18)>>3)|((((b)-'A'+1)&7)<<13)|\
183 ((((c)-'A'+1)&0x1f)<<8))
184 #define ISAPNP_DEVICE(x) ((((x)&0xf000)>>8)|\
185 (((x)&0x0f00)>>8)|\
186 (((x)&0x00f0)<<8)|\
187 (((x)&0x000f)<<8))
188
189 static void put_isapnp_id(FILE *out, const char *id)
190 {
191 unsigned short vendor, device;
192
193 vendor = ISAPNP_VENDOR(id[0], id[1], id[2]);
194 device = (unsigned short)strtol(&id[3], NULL, 16);
195 device = ISAPNP_DEVICE(device);
196 fprintf(out, " 0x%04x 0x%04x ", vendor, device);
197 }
198
199 int output_isapnp_table(struct module *modules, FILE *out, char *dirname)
200 {
201 struct module *i;
202
203 fprintf(out, "# isapnp module ");
204 fprintf(out, "cardvendor carddevice driver_data vendor function ...\n");
205
206 for (i = modules; i; i = i->next) {
207 char shortname[strlen(i->pathname) + 1];
208 struct module_tables *t = &i->tables;
209
210 if (t->pnp_table) {
211 struct pnp_device_id *id;
212 make_shortname(shortname, i->pathname);
213 for (id = t->pnp_table;
214 id->id[0];
215 id = (void *)id + t->pnp_size) {
216 fprintf(out, "%-20s", shortname);
217 fprintf(out, " 0xffff 0xffff ");
218 fprintf(out, " 0x00000000 "); /* driver_data */
219 put_isapnp_id(out, id->id);
220 fprintf(out, "\n");
221 }
222 }
223 if (t->pnp_card_table) {
224 void *id;
225 make_shortname(shortname, i->pathname);
226 for (id = t->pnp_card_table;
227 ((char *)id)[0];
228 id += t->pnp_card_size) {
229 int idx;
230 struct pnp_card_devid *devid
231 = id + t->pnp_card_offset;
232
233 fprintf(out, "%-20s", shortname);
234 put_isapnp_id(out, id);
235 fprintf(out, " 0x00000000 "); /* driver_data */
236 for (idx = 0; idx < 8; idx++) {
237 if (!devid->devid[idx][0])
238 break;
239 put_isapnp_id(out, devid->devid[idx]);
240 }
241 fprintf(out, "\n");
242 }
243 }
244 }
245 return 1;
246 }
247
248 #define MATCH_bustype 1
249 #define MATCH_vendor 2
250 #define MATCH_product 4
251 #define MATCH_version 8
252
253 #define MATCH_evbit 0x010
254 #define MATCH_keybit 0x020
255 #define MATCH_relbit 0x040
256 #define MATCH_absbit 0x080
257 #define MATCH_mscbit 0x100
258 #define MATCH_ledbit 0x200
259 #define MATCH_sndbit 0x400
260 #define MATCH_ffbit 0x800
261 #define MATCH_swbit 0x1000
262
263 #define MATCH(x) (END(input->match_flags, conv) & MATCH_ ## x)
264 #define PRINT_SCALAR(n) fprintf(out, " 0x%lx", MATCH(n) ? END(input->n, conv) : 0l)
265 #define PRINT_ARRAY64(n) do { \
266 fprintf(out, " "); \
267 if (MATCH(n)) \
268 output_input_bits_64(out, input->n, sizeof(input->n), conv); \
269 else \
270 fprintf(out, "%d", 0); \
271 } while (0)
272
273 #define PRINT_ARRAY32(n) do { \
274 fprintf(out, " "); \
275 if (MATCH(n)) \
276 output_input_bits_32(out, input->n, sizeof(input->n), conv); \
277 else \
278 fprintf(out, "%d", 0); \
279 } while (0)
280
281 static void output_input_bits_32(FILE *out, unsigned int *bits, int size,
282 int conv)
283 {
284 int i, j;
285
286 size /= sizeof(*bits);
287 for (i = size - 1; i >= 0; i--)
288 if (END(bits[i], conv))
289 break;
290 if (i < 0)
291 i = 0;
292 fprintf(out, "%x", END(bits[i], conv));
293 for (j = i - 1; j >= 0; j--)
294 fprintf(out, ":%x", END(bits[j], conv));
295 }
296
297 static void output_input_bits_64(FILE *out, unsigned long long *bits, int size,
298 int conv)
299 {
300 int i, j;
301
302 size /= sizeof(*bits);
303 for (i = size - 1; i >= 0; i--)
304 if (END(bits[i], conv))
305 break;
306 if (i < 0)
307 i = 0;
308 fprintf(out, "%llx", END(bits[i], conv));
309 for (j = i - 1; j >= 0; j--)
310 fprintf(out, ":%llx", END(bits[j], conv));
311 }
312
313 /* Formats are too different to */
314 static int output_input_entry_32(struct input_device_id_32 *input,
315 char *name, FILE *out, int conv)
316 {
317 if (!input->match_flags && !input->driver_info)
318 return 1;
319
320 fprintf(out, "%-20s0x%x", name, END(input->match_flags, conv));
321
322 PRINT_SCALAR(bustype);
323 PRINT_SCALAR(vendor);
324 PRINT_SCALAR(product);
325 PRINT_SCALAR(version);
326
327 PRINT_ARRAY32(evbit);
328 PRINT_ARRAY32(keybit);
329 PRINT_ARRAY32(relbit);
330 PRINT_ARRAY32(absbit);
331 PRINT_ARRAY32(mscbit);
332 PRINT_ARRAY32(ledbit);
333 PRINT_ARRAY32(sndbit);
334 PRINT_ARRAY32(ffbit);
335 PRINT_ARRAY32(swbit);
336
337 fprintf(out, " 0x%x\n", END(input->driver_info, conv));
338 return 0;
339 }
340
341 static int output_input_entry_32_old(struct input_device_id_old_32 *input,
342 char *name, FILE *out, int conv)
343 {
344 if (!input->match_flags && !input->driver_info)
345 return 1;
346
347 fprintf(out, "%-20s0x%x", name, END(input->match_flags, conv));
348
349 PRINT_SCALAR(bustype);
350 PRINT_SCALAR(vendor);
351 PRINT_SCALAR(product);
352 PRINT_SCALAR(version);
353
354 PRINT_ARRAY32(evbit);
355 PRINT_ARRAY32(keybit);
356 PRINT_ARRAY32(relbit);
357 PRINT_ARRAY32(absbit);
358 PRINT_ARRAY32(mscbit);
359 PRINT_ARRAY32(ledbit);
360 PRINT_ARRAY32(sndbit);
361 PRINT_ARRAY32(ffbit);
362
363 fprintf(out, " 0x%x\n", END(input->driver_info, conv));
364 return 0;
365 }
366
367 static int output_input_entry_64(struct input_device_id_64 *input,
368 char *name, FILE *out, int conv)
369 {
370 if (!input->match_flags && !input->driver_info)
371 return 1;
372
373 fprintf(out, "%-20s0x%llx", name, END(input->match_flags, conv));
374
375 PRINT_SCALAR(bustype);
376 PRINT_SCALAR(vendor);
377 PRINT_SCALAR(product);
378 PRINT_SCALAR(version);
379
380 PRINT_ARRAY64(evbit);
381 PRINT_ARRAY64(keybit);
382 PRINT_ARRAY64(relbit);
383 PRINT_ARRAY64(absbit);
384 PRINT_ARRAY64(mscbit);
385 PRINT_ARRAY64(ledbit);
386 PRINT_ARRAY64(sndbit);
387 PRINT_ARRAY64(ffbit);
388 PRINT_ARRAY64(swbit);
389
390 fprintf(out, " 0x%llx\n", END(input->driver_info, conv));
391 return 0;
392 }
393
394 static int output_input_entry_64_old(struct input_device_id_old_64 *input,
395 char *name, FILE *out, int conv)
396 {
397 if (!input->match_flags && !input->driver_info)
398 return 1;
399
400 fprintf(out, "%-20s0x%llx", name, END(input->match_flags, conv));
401
402 PRINT_SCALAR(bustype);
403 PRINT_SCALAR(vendor);
404 PRINT_SCALAR(product);
405 PRINT_SCALAR(version);
406
407 PRINT_ARRAY64(evbit);
408 PRINT_ARRAY64(keybit);
409 PRINT_ARRAY64(relbit);
410 PRINT_ARRAY64(absbit);
411 PRINT_ARRAY64(mscbit);
412 PRINT_ARRAY64(ledbit);
413 PRINT_ARRAY64(sndbit);
414 PRINT_ARRAY64(ffbit);
415
416 fprintf(out, " 0x%llx\n", END(input->driver_info, conv));
417 return 0;
418 }
419
420 int output_input_table(struct module *modules, FILE *out, char *dirname)
421 {
422 struct module *i;
423
424 fprintf(out, "# module matchBits");
425 fprintf(out, " bustype vendor product version evBits keyBits relBits");
426 fprintf(out, " absBits mscBits ledBits sndBits ffBits [swBits] driver_info\n");
427
428 for (i = modules; i; i = i->next) {
429 void *p;
430 char shortname[strlen(i->pathname) + 1];
431 int done = 0;
432 struct module_tables *t = &i->tables;
433 int conv = i->file->conv;
434
435 if (!t->input_table)
436 continue;
437
438 make_shortname(shortname, i->pathname);
439 /* Guess what size it really is, based on size of
440 * whole table. Table changed in 2.6.14. This is a hack. */
441 if (t->input_size == sizeof(struct input_device_id_old_64)) {
442 if ((t->input_table_size % t->input_size) != 0) {
443 t->input_size
444 = sizeof(struct input_device_id_64);
445 }
446 } else {
447 if ((t->input_table_size % t->input_size) != 0) {
448 t->input_size
449 = sizeof(struct input_device_id_32);
450 }
451 }
452
453 for (p = t->input_table; !done; p += t->input_size) {
454 switch (t->input_size) {
455 case sizeof(struct input_device_id_old_64):
456 done = output_input_entry_64_old(p,
457 shortname,
458 out, conv);
459 break;
460 case sizeof(struct input_device_id_64):
461 done = output_input_entry_64(p, shortname,
462 out, conv);
463 break;
464 case sizeof(struct input_device_id_old_32):
465 done = output_input_entry_32_old(p,
466 shortname,
467 out, conv);
468 break;
469 case sizeof(struct input_device_id_32):
470 done = output_input_entry_32(p, shortname,
471 out, conv);
472 break;
473 }
474 }
475 }
476 return 1;
477 }
478
479 static void output_serio_entry(struct serio_device_id *serio, char *name, FILE *out)
480 {
481 fprintf(out,
482 "%-20s 0x%02x 0x%02x 0x%02x 0x%02x\n",
483 name,
484 serio->type,
485 serio->extra,
486 serio->id,
487 serio->proto);
488 }
489
490
491 int output_serio_table(struct module *modules, FILE *out, char *dirname)
492 {
493 struct module *i;
494
495 fprintf(out, "# serio module type extra id proto\n");
496
497 for (i = modules; i; i = i->next) {
498 struct serio_device_id *e;
499 char shortname[strlen(i->pathname) + 1];
500 struct module_tables *t = &i->tables;
501
502 if (!t->serio_table)
503 continue;
504
505 make_shortname(shortname, i->pathname);
506 for (e = t->serio_table; e->type || e->proto; e = (void *)e + t->serio_size)
507 output_serio_entry(e, shortname, out);
508 }
509 return 1;
510 }
511
512
513 static void
514 strip_whitespace (char *str, char chr)
515 {
516 int i;
517 if (!str)
518 return;
519 for (i = strlen (str); i >= 0; --i)
520 if (isspace (*str))
521 *str = chr;
522 }
523
524 /* We set driver_data to zero */
525 static void output_of_entry(struct of_device_id *dev, char *name, FILE *out)
526 {
527 char *ofname = NULL, *type = NULL, *compatible = NULL;
528 if (dev->name[0]) {
529 ofname = strdup (dev->name);
530 strip_whitespace (ofname, '_');
531 }
532
533 if (dev->type[0]) {
534 type = strdup (dev->type);
535 strip_whitespace (type, '_');
536 }
537
538 if (dev->compatible[0]) {
539 compatible = strdup (dev->compatible);
540 strip_whitespace (compatible, '_');
541 }
542
543 fprintf (out, "%-20s %-20s %-20s %s\n",
544 name, ofname ? ofname : "*", type ? type : "*",
545 compatible ? compatible : "*");
546
547 free(ofname);
548 free(type);
549 free(compatible);
550 }
551
552 int output_of_table(struct module *modules, FILE *out, char *dirname)
553 {
554 struct module *i;
555
556 fprintf (out, "# of module name type compatible\n");
557 for (i = modules; i; i = i->next) {
558 struct of_device_id *e;
559 char shortname[strlen(i->pathname) + 1];
560 struct module_tables *t = &i->tables;
561
562 if (!t->of_table)
563 continue;
564
565 make_shortname(shortname, i->pathname);
566 for (e = t->of_table; e->name[0]|e->type[0]|e->compatible[0];
567 e = (void *)e + t->of_size)
568 output_of_entry(e, shortname, out);
569 }
570 return 1;
571 }
module-init-tools