~apw/module-init-tools/resync2

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include "depmod.h"
#include "tables.h"
#include "util.h"

/* Turn /lib/modules/2.5.49/kernel/foo.ko(.gz) => foo */
static void make_shortname(char *dest, const char *src)
{
	char *ext;
	const char *bname;

	bname = my_basename(src);
	strcpy(dest, bname);
	ext = strchr(dest, '.');
	if (ext)
		*ext = '\0';
}

/* We set driver_data to zero */
static void output_pci_entry(struct pci_device_id *pci, char *name, FILE *out,
			     int conv)
{
	fprintf(out,
		"%-20s 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x0\n",
		name,
		END(pci->vendor, conv),
		END(pci->device, conv),
		END(pci->subvendor, conv),
		END(pci->subdevice, conv),
		END(pci->class, conv),
		END(pci->class_mask, conv));
}

int output_pci_table(struct module *modules, FILE *out, char *dirname)
{
	struct module *i;

	fprintf(out, "# pci module         vendor     device     subvendor"
		"  subdevice  class      class_mask driver_data\n");

	for (i = modules; i; i = i->next) {
		struct pci_device_id *e;
		char shortname[strlen(i->pathname) + 1];
		struct module_tables *t = &i->tables;

		if (!t->pci_table)
			continue;

		make_shortname(shortname, i->pathname);
		for (e = t->pci_table; e->vendor; e = (void *)e + t->pci_size)
			output_pci_entry(e, shortname, out, i->file->conv);
	}
	return 1;
}

/* We set driver_info to zero */
static void output_usb_entry(struct usb_device_id *usb, char *name, FILE *out,
			     int conv)
{
	fprintf(out, "%-20s 0x%04x      0x%04x   0x%04x    0x%04x"
		"       0x%04x       0x%02x         0x%02x"
		"            0x%02x            0x%02x"
		"            0x%02x               0x%02x"
		"               0x0\n",
		name,
		END(usb->match_flags, conv),
		END(usb->idVendor, conv),
		END(usb->idProduct, conv),
		END(usb->bcdDevice_lo, conv),
		END(usb->bcdDevice_hi, conv),
		END(usb->bDeviceClass, conv),
		END(usb->bDeviceSubClass, conv),
		END(usb->bDeviceProtocol, conv),
		END(usb->bInterfaceClass, conv),
		END(usb->bInterfaceSubClass, conv),
		END(usb->bInterfaceProtocol, conv));
}

int output_usb_table(struct module *modules, FILE *out, char *dirname)
{
	struct module *i;

	fprintf(out, "# usb module         ");
	/* Requires all users to be on kernel 2.4.0 or later */
	fprintf(out, "match_flags ");
	fprintf(out, "idVendor idProduct bcdDevice_lo bcdDevice_hi"
		" bDeviceClass bDeviceSubClass bDeviceProtocol"
		" bInterfaceClass bInterfaceSubClass"
		" bInterfaceProtocol driver_info\n");

	for (i = modules; i; i = i->next) {
		struct usb_device_id *e;
		char shortname[strlen(i->pathname) + 1];
		struct module_tables *t = &i->tables;

		if (!t->usb_table)
			continue;

		make_shortname(shortname, i->pathname);
		for (e = t->usb_table;
		     e->idVendor || e->bDeviceClass || e->bInterfaceClass;
		     e = (void *)e + t->usb_size)
			output_usb_entry(e, shortname, out, i->file->conv);
	}
	return 1;
}

static void output_ieee1394_entry(struct ieee1394_device_id *fw, char *name,
				  FILE *out, int conv)
{
	fprintf(out, "%-20s 0x%08x  0x%06x  0x%06x 0x%06x     0x%06x\n",
		name,
		END(fw->match_flags, conv),
		END(fw->vendor_id, conv),
		END(fw->model_id, conv),
		END(fw->specifier_id, conv),
		END(fw->version, conv));
}

int output_ieee1394_table(struct module *modules, FILE *out, char *dirname)
{
	struct module *i;

	fprintf(out, "# ieee1394 module    ");
	fprintf(out, "match_flags vendor_id model_id specifier_id version\n");

	for (i = modules; i; i = i->next) {
		struct ieee1394_device_id *fw;
		char shortname[strlen(i->pathname) + 1];
		struct module_tables *t = &i->tables;

		if (!t->ieee1394_table)
			continue;

		make_shortname(shortname, i->pathname);
		for (fw = t->ieee1394_table; fw->match_flags;
		     fw = (void *) fw + t->ieee1394_size)
			output_ieee1394_entry(fw, shortname, out, i->file->conv);
	}
	return 1;
}


/* We set driver_data to zero */
static void output_ccw_entry(struct ccw_device_id *ccw, char *name, FILE *out,
			     int conv)
{
	fprintf(out, "%-20s 0x%04x      0x%04x  0x%02x      0x%04x  0x%02x\n",
		name, END(ccw->match_flags, conv),
		END(ccw->cu_type, conv),  END(ccw->cu_model, conv),
		END(ccw->dev_type, conv), END(ccw->dev_model, conv));
}

int output_ccw_table(struct module *modules, FILE *out, char *dirname)
{
	struct module *i;

	fprintf(out, "# ccw module         ");
	fprintf(out, "match_flags cu_type cu_model dev_type dev_model\n");

	for (i = modules; i; i = i->next) {
		struct ccw_device_id *e;
		char shortname[strlen(i->pathname) + 1];
		struct module_tables *t = &i->tables;

		if (!t->ccw_table)
			continue;

		make_shortname(shortname, i->pathname);
		for (e = t->ccw_table;
		     e->cu_type || e->cu_model || e->dev_type || e->dev_model;
		     e = (void *) e + t->ccw_size)
			output_ccw_entry(e, shortname, out, i->file->conv);
	}
	return 1;
}

#define ISAPNP_VENDOR(a,b,c)	(((((a)-'A'+1)&0x3f)<<2)|\
				((((b)-'A'+1)&0x18)>>3)|((((b)-'A'+1)&7)<<13)|\
				((((c)-'A'+1)&0x1f)<<8))
#define ISAPNP_DEVICE(x)	((((x)&0xf000)>>8)|\
				 (((x)&0x0f00)>>8)|\
				 (((x)&0x00f0)<<8)|\
				 (((x)&0x000f)<<8))

static void put_isapnp_id(FILE *out, const char *id)
{
	unsigned short vendor, device;

	vendor = ISAPNP_VENDOR(id[0], id[1], id[2]);
	device = (unsigned short)strtol(&id[3], NULL, 16);
	device = ISAPNP_DEVICE(device);
	fprintf(out, " 0x%04x     0x%04x    ", vendor, device);
}

int output_isapnp_table(struct module *modules, FILE *out, char *dirname)
{
	struct module *i;

	fprintf(out, "# isapnp module      ");
	fprintf(out, "cardvendor carddevice driver_data vendor     function   ...\n");

	for (i = modules; i; i = i->next) {
		char shortname[strlen(i->pathname) + 1];
		struct module_tables *t = &i->tables;

		if (t->pnp_table) {
			struct pnp_device_id *id;
			make_shortname(shortname, i->pathname);
			for (id = t->pnp_table;
			     id->id[0];
			     id = (void *)id + t->pnp_size) {
				fprintf(out, "%-20s", shortname);
				fprintf(out, " 0xffff     0xffff    ");
				fprintf(out, " 0x00000000 "); /* driver_data */
				put_isapnp_id(out, id->id);
				fprintf(out, "\n");
			}
		}
		if (t->pnp_card_table) {
			void *id;
			make_shortname(shortname, i->pathname);
			for (id = t->pnp_card_table;
			     ((char *)id)[0];
			     id += t->pnp_card_size) {
				int idx;
				struct pnp_card_devid *devid
					= id + t->pnp_card_offset;

				fprintf(out, "%-20s", shortname);
				put_isapnp_id(out, id);
				fprintf(out, " 0x00000000 "); /* driver_data */
				for (idx = 0; idx < 8; idx++) {
					if (!devid->devid[idx][0])
						break;
					put_isapnp_id(out, devid->devid[idx]);
				}
				fprintf(out, "\n");
			}
		}
	}
	return 1;
}

#define MATCH_bustype   1
#define MATCH_vendor    2
#define MATCH_product   4
#define MATCH_version   8

#define MATCH_evbit     0x010
#define MATCH_keybit    0x020
#define MATCH_relbit    0x040
#define MATCH_absbit    0x080
#define MATCH_mscbit    0x100
#define MATCH_ledbit    0x200
#define MATCH_sndbit    0x400
#define MATCH_ffbit     0x800
#define MATCH_swbit     0x1000

#define MATCH(x) (END(input->match_flags, conv) & MATCH_ ## x)
#define PRINT_SCALAR(n) fprintf(out, "  0x%lx", MATCH(n) ? END(input->n, conv) : 0l)
#define PRINT_ARRAY64(n) do {						    \
	fprintf(out, "  ");						    \
	if (MATCH(n))							    \
		output_input_bits_64(out, input->n, sizeof(input->n), conv); \
	else								    \
		fprintf(out, "%d", 0);					    \
	} while (0)

#define PRINT_ARRAY32(n) do {						    \
	fprintf(out, "  ");						    \
	if (MATCH(n))							    \
		output_input_bits_32(out, input->n, sizeof(input->n), conv); \
	else								    \
		fprintf(out, "%d", 0);					    \
	} while (0)

static void output_input_bits_32(FILE *out, unsigned int *bits, int size,
				 int conv)
{
	int i, j;

	size /= sizeof(*bits);
	for (i = size - 1; i >= 0; i--)
		 if (END(bits[i], conv))
			 break;
	if (i < 0)
		i = 0;
	fprintf(out, "%x", END(bits[i], conv));
	for (j = i - 1; j >= 0; j--)
		fprintf(out, ":%x", END(bits[j], conv));
}

static void output_input_bits_64(FILE *out, unsigned long long *bits, int size,
				 int conv)
{
	int i, j;

	size /= sizeof(*bits);
	for (i = size - 1; i >= 0; i--)
		 if (END(bits[i], conv))
			 break;
	if (i < 0)
		i = 0;
	fprintf(out, "%llx", END(bits[i], conv));
	for (j = i - 1; j >= 0; j--)
		fprintf(out, ":%llx", END(bits[j], conv));
}

/* Formats are too different to */
static int output_input_entry_32(struct input_device_id_32 *input,
				 char *name, FILE *out, int conv)
{
	if (!input->match_flags && !input->driver_info)
		return 1;

	fprintf(out, "%-20s0x%x", name, END(input->match_flags, conv));

	PRINT_SCALAR(bustype);
	PRINT_SCALAR(vendor);
	PRINT_SCALAR(product);
	PRINT_SCALAR(version);

	PRINT_ARRAY32(evbit);
	PRINT_ARRAY32(keybit);
	PRINT_ARRAY32(relbit);
	PRINT_ARRAY32(absbit);
	PRINT_ARRAY32(mscbit);
	PRINT_ARRAY32(ledbit);
	PRINT_ARRAY32(sndbit);
	PRINT_ARRAY32(ffbit);
	PRINT_ARRAY32(swbit);

	fprintf(out, "  0x%x\n", END(input->driver_info, conv));
	return 0;
}

static int output_input_entry_32_old(struct input_device_id_old_32 *input,
				     char *name, FILE *out, int conv)
{
	if (!input->match_flags && !input->driver_info)
		return 1;

	fprintf(out, "%-20s0x%x", name, END(input->match_flags, conv));

	PRINT_SCALAR(bustype);
	PRINT_SCALAR(vendor);
	PRINT_SCALAR(product);
	PRINT_SCALAR(version);

	PRINT_ARRAY32(evbit);
	PRINT_ARRAY32(keybit);
	PRINT_ARRAY32(relbit);
	PRINT_ARRAY32(absbit);
	PRINT_ARRAY32(mscbit);
	PRINT_ARRAY32(ledbit);
	PRINT_ARRAY32(sndbit);
	PRINT_ARRAY32(ffbit);

	fprintf(out, "  0x%x\n", END(input->driver_info, conv));
	return 0;
}

static int output_input_entry_64(struct input_device_id_64 *input,
				 char *name, FILE *out, int conv)
{
	if (!input->match_flags && !input->driver_info)
		return 1;

	fprintf(out, "%-20s0x%llx", name, END(input->match_flags, conv));

	PRINT_SCALAR(bustype);
	PRINT_SCALAR(vendor);
	PRINT_SCALAR(product);
	PRINT_SCALAR(version);

	PRINT_ARRAY64(evbit);
	PRINT_ARRAY64(keybit);
	PRINT_ARRAY64(relbit);
	PRINT_ARRAY64(absbit);
	PRINT_ARRAY64(mscbit);
	PRINT_ARRAY64(ledbit);
	PRINT_ARRAY64(sndbit);
	PRINT_ARRAY64(ffbit);
	PRINT_ARRAY64(swbit);

	fprintf(out, "  0x%llx\n", END(input->driver_info, conv));
	return 0;
}

static int output_input_entry_64_old(struct input_device_id_old_64 *input,
				     char *name, FILE *out, int conv)
{
	if (!input->match_flags && !input->driver_info)
		return 1;

	fprintf(out, "%-20s0x%llx", name, END(input->match_flags, conv));

	PRINT_SCALAR(bustype);
	PRINT_SCALAR(vendor);
	PRINT_SCALAR(product);
	PRINT_SCALAR(version);

	PRINT_ARRAY64(evbit);
	PRINT_ARRAY64(keybit);
	PRINT_ARRAY64(relbit);
	PRINT_ARRAY64(absbit);
	PRINT_ARRAY64(mscbit);
	PRINT_ARRAY64(ledbit);
	PRINT_ARRAY64(sndbit);
	PRINT_ARRAY64(ffbit);

	fprintf(out, "  0x%llx\n", END(input->driver_info, conv));
	return 0;
}

int output_input_table(struct module *modules, FILE *out, char *dirname)
{
	struct module *i;

	fprintf(out, "# module         matchBits");
	fprintf(out, " bustype vendor product version evBits keyBits relBits");
	fprintf(out, " absBits mscBits ledBits sndBits ffBits [swBits] driver_info\n");

	for (i = modules; i; i = i->next) {
		void *p;
		char shortname[strlen(i->pathname) + 1];
		int done = 0;
		struct module_tables *t = &i->tables;
		int conv = i->file->conv;

		if (!t->input_table)
			continue;

		make_shortname(shortname, i->pathname);
		/* Guess what size it really is, based on size of
		 * whole table.  Table changed in 2.6.14.  This is a hack. */
		if (t->input_size == sizeof(struct input_device_id_old_64)) {
			if ((t->input_table_size % t->input_size) != 0) {
				t->input_size
					= sizeof(struct input_device_id_64);
			}
		} else {
			if ((t->input_table_size % t->input_size) != 0) {
				t->input_size
					= sizeof(struct input_device_id_32);
			}
		}

		for (p = t->input_table; !done; p += t->input_size) {
			switch (t->input_size) {
			case sizeof(struct input_device_id_old_64):
				done = output_input_entry_64_old(p,
								 shortname,
								 out, conv);
				break;
			case sizeof(struct input_device_id_64):
				done = output_input_entry_64(p, shortname,
							     out, conv);
				break;
			case sizeof(struct input_device_id_old_32):
				done = output_input_entry_32_old(p,
								 shortname,
								 out, conv);
				break;
			case sizeof(struct input_device_id_32):
				done = output_input_entry_32(p, shortname,
							     out, conv);
				break;
			}
		}				
	}
	return 1;
}

static void output_serio_entry(struct serio_device_id *serio, char *name, FILE *out)
{
	fprintf(out,
		"%-20s 0x%02x 0x%02x  0x%02x 0x%02x\n",
		name,
		serio->type,
		serio->extra,
		serio->id,
		serio->proto);
}


int output_serio_table(struct module *modules, FILE *out, char *dirname)
{
	struct module *i;

	fprintf(out, "# serio module       type extra id   proto\n");

	for (i = modules; i; i = i->next) {
		struct serio_device_id *e;
		char shortname[strlen(i->pathname) + 1];
		struct module_tables *t = &i->tables;

		if (!t->serio_table)
			continue;

		make_shortname(shortname, i->pathname);
		for (e = t->serio_table; e->type || e->proto; e = (void *)e + t->serio_size)
			output_serio_entry(e, shortname, out);
	}
	return 1;
}


static void
strip_whitespace (char *str, char chr)
{
	int i;
	if (!str)
		return;
	for (i = strlen (str); i >= 0; --i)
		if (isspace (*str))
			*str = chr;
}

/* We set driver_data to zero */
static void output_of_entry(struct of_device_id *dev, char *name, FILE *out)
{
	char *ofname = NULL, *type = NULL, *compatible = NULL;
	if (dev->name[0]) {
		ofname = strdup (dev->name);
		strip_whitespace (ofname, '_');
	}

	if (dev->type[0]) {
		type = strdup (dev->type);
		strip_whitespace (type, '_');
       }

	if (dev->compatible[0]) {
		compatible = strdup (dev->compatible);
		strip_whitespace (compatible, '_');
	}

        fprintf (out, "%-20s %-20s %-20s %s\n",
                name, ofname ? ofname : "*", type ? type : "*",
                compatible ? compatible : "*");
	
	free(ofname);
	free(type);
	free(compatible);
}

int output_of_table(struct module *modules, FILE *out, char *dirname)
{
	struct module *i;

        fprintf (out, "# of module          name                 type                 compatible\n");                                 
	for (i = modules; i; i = i->next) {
		struct of_device_id *e;
		char shortname[strlen(i->pathname) + 1];
		struct module_tables *t = &i->tables;

		if (!t->of_table)
			continue;

		make_shortname(shortname, i->pathname);
		for (e = t->of_table; e->name[0]|e->type[0]|e->compatible[0];
                     e = (void *)e + t->of_size)
			output_of_entry(e, shortname, out);
	}
	return 1;
}