2005-04-17 00:20:36 +02:00
|
|
|
/* Simple code to turn various tables in an ELF file into alias definitions.
|
|
|
|
* This deals with kernel datastructures where they should be
|
|
|
|
* dealt with: in the kernel source.
|
|
|
|
*
|
|
|
|
* Copyright 2002-2003 Rusty Russell, IBM Corporation
|
|
|
|
* 2003 Kai Germaschewski
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* This software may be used and distributed according to the terms
|
|
|
|
* of the GNU General Public License, incorporated herein by reference.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "modpost.h"
|
|
|
|
|
|
|
|
/* We use the ELF typedefs for kernel_ulong_t but bite the bullet and
|
|
|
|
* use either stdint.h or inttypes.h for the rest. */
|
|
|
|
#if KERNEL_ELFCLASS == ELFCLASS32
|
|
|
|
typedef Elf32_Addr kernel_ulong_t;
|
2005-12-07 21:40:34 +01:00
|
|
|
#define BITS_PER_LONG 32
|
2005-04-17 00:20:36 +02:00
|
|
|
#else
|
|
|
|
typedef Elf64_Addr kernel_ulong_t;
|
2005-12-07 21:40:34 +01:00
|
|
|
#define BITS_PER_LONG 64
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif
|
|
|
|
#ifdef __sun__
|
|
|
|
#include <inttypes.h>
|
|
|
|
#else
|
|
|
|
#include <stdint.h>
|
|
|
|
#endif
|
|
|
|
|
2005-07-06 21:44:41 +02:00
|
|
|
#include <ctype.h>
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
typedef uint32_t __u32;
|
|
|
|
typedef uint16_t __u16;
|
|
|
|
typedef unsigned char __u8;
|
|
|
|
|
|
|
|
/* Big exception to the "don't include kernel headers into userspace, which
|
2006-03-03 16:46:04 +01:00
|
|
|
* even potentially has different endianness and word sizes, since
|
2005-04-17 00:20:36 +02:00
|
|
|
* we handle those differences explicitly below */
|
|
|
|
#include "../../include/linux/mod_devicetable.h"
|
|
|
|
|
|
|
|
#define ADD(str, sep, cond, field) \
|
|
|
|
do { \
|
|
|
|
strcat(str, sep); \
|
|
|
|
if (cond) \
|
|
|
|
sprintf(str + strlen(str), \
|
|
|
|
sizeof(field) == 1 ? "%02X" : \
|
|
|
|
sizeof(field) == 2 ? "%04X" : \
|
|
|
|
sizeof(field) == 4 ? "%08X" : "", \
|
|
|
|
field); \
|
|
|
|
else \
|
|
|
|
sprintf(str + strlen(str), "*"); \
|
|
|
|
} while(0)
|
|
|
|
|
modpost: i2c aliases need no trailing wildcard
Not all device types need a wildcard at the end of their module
aliases. In particular, for i2c module aliases, the trailing wildcard
is not only unneeded, it could also cause the wrong driver to be
loaded.
As I2C devices have no IDs, i2c module aliases are simple, arbitrary
device names. For example:
$ /sbin/modinfo lm90
filename: /lib/modules/2.6.25-git18/kernel/drivers/hwmon/lm90.ko
author: Jean Delvare <khali@linux-fr.org>
description: LM90/ADM1032 driver
license: GPL
vermagic: 2.6.25-git18 mod_unload
depends: hwmon
alias: i2c:lm90*
alias: i2c:adm1032*
alias: i2c:lm99*
alias: i2c:lm86*
alias: i2c:max6657*
alias: i2c:adt7461*
alias: i2c:max6680*
$
This would cause trouble if one I2C chip name matches the beginning of
another I2C chip name and both chips are supported by different
drivers. For example, an i2c device named lm9042 would cause the lm90
driver to be loaded, while it doesn't support that device. This case
has yet to be seen in practice, but still, I'd like to fix it now. The
cleanest fix is to remove the trailing wildcard from i2c module aliases.
Here's a patch doing this.
Not all device type aliases need a trailing wildcard, in particular
the i2c aliases don't. Don't add a wildcard by default in do_table(),
instead let each device type handler add it if needed.
I have tested types acpi, dmi, eisa, i2c, ide, ieee1394, input, pci,
pcmcia, platform, pnp, scsi, serio, ssb and usb. Other types (ccw, of,
vio, parisc, sdio and virtio) are untested.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Acked-by: Jochen Friedrich <jochen@scram.de>
Signed-off-by: Sam Ravnborg <sam@ravnborg.org>
2008-05-02 20:37:21 +02:00
|
|
|
/* Always end in a wildcard, for future extension */
|
|
|
|
static inline void add_wildcard(char *str)
|
|
|
|
{
|
|
|
|
int len = strlen(str);
|
|
|
|
|
|
|
|
if (str[len - 1] != '*')
|
|
|
|
strcat(str + len, "*");
|
|
|
|
}
|
|
|
|
|
2008-03-23 21:38:54 +01:00
|
|
|
unsigned int cross_build = 0;
|
2006-07-09 16:26:07 +02:00
|
|
|
/**
|
|
|
|
* Check that sizeof(device_id type) are consistent with size of section
|
|
|
|
* in .o file. If in-consistent then userspace and kernel does not agree
|
|
|
|
* on actual size which is a bug.
|
2007-09-16 11:15:46 +02:00
|
|
|
* Also verify that the final entry in the table is all zeros.
|
2008-03-23 21:38:54 +01:00
|
|
|
* Ignore both checks if build host differ from target host and size differs.
|
2006-07-09 16:26:07 +02:00
|
|
|
**/
|
2007-09-16 11:15:46 +02:00
|
|
|
static void device_id_check(const char *modname, const char *device_id,
|
|
|
|
unsigned long size, unsigned long id_size,
|
|
|
|
void *symval)
|
2006-07-09 16:26:07 +02:00
|
|
|
{
|
2007-09-16 11:15:46 +02:00
|
|
|
int i;
|
|
|
|
|
2006-07-09 16:26:07 +02:00
|
|
|
if (size % id_size || size < id_size) {
|
2008-03-23 21:38:54 +01:00
|
|
|
if (cross_build != 0)
|
|
|
|
return;
|
2006-07-09 16:26:07 +02:00
|
|
|
fatal("%s: sizeof(struct %s_device_id)=%lu is not a modulo "
|
|
|
|
"of the size of section __mod_%s_device_table=%lu.\n"
|
|
|
|
"Fix definition of struct %s_device_id "
|
|
|
|
"in mod_devicetable.h\n",
|
|
|
|
modname, device_id, id_size, device_id, size, device_id);
|
|
|
|
}
|
2007-09-16 11:15:46 +02:00
|
|
|
/* Verify last one is a terminator */
|
|
|
|
for (i = 0; i < id_size; i++ ) {
|
|
|
|
if (*(uint8_t*)(symval+size-id_size+i)) {
|
|
|
|
fprintf(stderr,"%s: struct %s_device_id is %lu bytes. "
|
|
|
|
"The last of %lu is:\n",
|
|
|
|
modname, device_id, id_size, size / id_size);
|
|
|
|
for (i = 0; i < id_size; i++ )
|
|
|
|
fprintf(stderr,"0x%02x ",
|
|
|
|
*(uint8_t*)(symval+size-id_size+i) );
|
|
|
|
fprintf(stderr,"\n");
|
|
|
|
fatal("%s: struct %s_device_id is not terminated "
|
|
|
|
"with a NULL entry!\n", modname, device_id);
|
|
|
|
}
|
|
|
|
}
|
2006-07-09 16:26:07 +02:00
|
|
|
}
|
|
|
|
|
2005-04-23 00:07:01 +02:00
|
|
|
/* USB is special because the bcdDevice can be matched against a numeric range */
|
|
|
|
/* Looks like "usb:vNpNdNdcNdscNdpNicNiscNipN" */
|
|
|
|
static void do_usb_entry(struct usb_device_id *id,
|
|
|
|
unsigned int bcdDevice_initial, int bcdDevice_initial_digits,
|
|
|
|
unsigned char range_lo, unsigned char range_hi,
|
|
|
|
struct module *mod)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-04-23 00:07:01 +02:00
|
|
|
char alias[500];
|
2005-04-17 00:20:36 +02:00
|
|
|
strcpy(alias, "usb:");
|
|
|
|
ADD(alias, "v", id->match_flags&USB_DEVICE_ID_MATCH_VENDOR,
|
|
|
|
id->idVendor);
|
|
|
|
ADD(alias, "p", id->match_flags&USB_DEVICE_ID_MATCH_PRODUCT,
|
|
|
|
id->idProduct);
|
2005-04-23 00:07:01 +02:00
|
|
|
|
|
|
|
strcat(alias, "d");
|
|
|
|
if (bcdDevice_initial_digits)
|
|
|
|
sprintf(alias + strlen(alias), "%0*X",
|
|
|
|
bcdDevice_initial_digits, bcdDevice_initial);
|
|
|
|
if (range_lo == range_hi)
|
|
|
|
sprintf(alias + strlen(alias), "%u", range_lo);
|
|
|
|
else if (range_lo > 0 || range_hi < 9)
|
|
|
|
sprintf(alias + strlen(alias), "[%u-%u]", range_lo, range_hi);
|
|
|
|
if (bcdDevice_initial_digits < (sizeof(id->bcdDevice_lo) * 2 - 1))
|
|
|
|
strcat(alias, "*");
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
ADD(alias, "dc", id->match_flags&USB_DEVICE_ID_MATCH_DEV_CLASS,
|
|
|
|
id->bDeviceClass);
|
|
|
|
ADD(alias, "dsc",
|
|
|
|
id->match_flags&USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
|
|
|
|
id->bDeviceSubClass);
|
|
|
|
ADD(alias, "dp",
|
|
|
|
id->match_flags&USB_DEVICE_ID_MATCH_DEV_PROTOCOL,
|
|
|
|
id->bDeviceProtocol);
|
|
|
|
ADD(alias, "ic",
|
|
|
|
id->match_flags&USB_DEVICE_ID_MATCH_INT_CLASS,
|
|
|
|
id->bInterfaceClass);
|
|
|
|
ADD(alias, "isc",
|
|
|
|
id->match_flags&USB_DEVICE_ID_MATCH_INT_SUBCLASS,
|
|
|
|
id->bInterfaceSubClass);
|
|
|
|
ADD(alias, "ip",
|
|
|
|
id->match_flags&USB_DEVICE_ID_MATCH_INT_PROTOCOL,
|
|
|
|
id->bInterfaceProtocol);
|
2005-04-23 00:07:01 +02:00
|
|
|
|
modpost: i2c aliases need no trailing wildcard
Not all device types need a wildcard at the end of their module
aliases. In particular, for i2c module aliases, the trailing wildcard
is not only unneeded, it could also cause the wrong driver to be
loaded.
As I2C devices have no IDs, i2c module aliases are simple, arbitrary
device names. For example:
$ /sbin/modinfo lm90
filename: /lib/modules/2.6.25-git18/kernel/drivers/hwmon/lm90.ko
author: Jean Delvare <khali@linux-fr.org>
description: LM90/ADM1032 driver
license: GPL
vermagic: 2.6.25-git18 mod_unload
depends: hwmon
alias: i2c:lm90*
alias: i2c:adm1032*
alias: i2c:lm99*
alias: i2c:lm86*
alias: i2c:max6657*
alias: i2c:adt7461*
alias: i2c:max6680*
$
This would cause trouble if one I2C chip name matches the beginning of
another I2C chip name and both chips are supported by different
drivers. For example, an i2c device named lm9042 would cause the lm90
driver to be loaded, while it doesn't support that device. This case
has yet to be seen in practice, but still, I'd like to fix it now. The
cleanest fix is to remove the trailing wildcard from i2c module aliases.
Here's a patch doing this.
Not all device type aliases need a trailing wildcard, in particular
the i2c aliases don't. Don't add a wildcard by default in do_table(),
instead let each device type handler add it if needed.
I have tested types acpi, dmi, eisa, i2c, ide, ieee1394, input, pci,
pcmcia, platform, pnp, scsi, serio, ssb and usb. Other types (ccw, of,
vio, parisc, sdio and virtio) are untested.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Acked-by: Jochen Friedrich <jochen@scram.de>
Signed-off-by: Sam Ravnborg <sam@ravnborg.org>
2008-05-02 20:37:21 +02:00
|
|
|
add_wildcard(alias);
|
2005-04-23 00:07:01 +02:00
|
|
|
buf_printf(&mod->dev_table_buf,
|
|
|
|
"MODULE_ALIAS(\"%s\");\n", alias);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void do_usb_entry_multi(struct usb_device_id *id, struct module *mod)
|
|
|
|
{
|
|
|
|
unsigned int devlo, devhi;
|
|
|
|
unsigned char chi, clo;
|
|
|
|
int ndigits;
|
|
|
|
|
|
|
|
id->match_flags = TO_NATIVE(id->match_flags);
|
|
|
|
id->idVendor = TO_NATIVE(id->idVendor);
|
|
|
|
id->idProduct = TO_NATIVE(id->idProduct);
|
|
|
|
|
|
|
|
devlo = id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO ?
|
|
|
|
TO_NATIVE(id->bcdDevice_lo) : 0x0U;
|
|
|
|
devhi = id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI ?
|
|
|
|
TO_NATIVE(id->bcdDevice_hi) : ~0x0U;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Some modules (visor) have empty slots as placeholder for
|
|
|
|
* run-time specification that results in catch-all alias
|
|
|
|
*/
|
2008-01-28 18:50:12 +01:00
|
|
|
if (!(id->idVendor | id->idProduct | id->bDeviceClass | id->bInterfaceClass))
|
2005-04-23 00:07:01 +02:00
|
|
|
return;
|
|
|
|
|
|
|
|
/* Convert numeric bcdDevice range into fnmatch-able pattern(s) */
|
|
|
|
for (ndigits = sizeof(id->bcdDevice_lo) * 2 - 1; devlo <= devhi; ndigits--) {
|
|
|
|
clo = devlo & 0xf;
|
|
|
|
chi = devhi & 0xf;
|
|
|
|
if (chi > 9) /* it's bcd not hex */
|
|
|
|
chi = 9;
|
|
|
|
devlo >>= 4;
|
|
|
|
devhi >>= 4;
|
|
|
|
|
|
|
|
if (devlo == devhi || !ndigits) {
|
|
|
|
do_usb_entry(id, devlo, ndigits, clo, chi, mod);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (clo > 0)
|
|
|
|
do_usb_entry(id, devlo++, ndigits, clo, 9, mod);
|
|
|
|
|
|
|
|
if (chi < 9)
|
|
|
|
do_usb_entry(id, devhi--, ndigits, 0, chi, mod);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void do_usb_table(void *symval, unsigned long size,
|
|
|
|
struct module *mod)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
const unsigned long id_size = sizeof(struct usb_device_id);
|
|
|
|
|
2007-09-16 11:15:46 +02:00
|
|
|
device_id_check(mod->name, "usb", size, id_size, symval);
|
2006-07-09 16:26:07 +02:00
|
|
|
|
2005-04-23 00:07:01 +02:00
|
|
|
/* Leave last one: it's the terminator. */
|
|
|
|
size -= id_size;
|
|
|
|
|
|
|
|
for (i = 0; i < size; i += id_size)
|
|
|
|
do_usb_entry_multi(symval + i, mod);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Looks like: ieee1394:venNmoNspNverN */
|
|
|
|
static int do_ieee1394_entry(const char *filename,
|
|
|
|
struct ieee1394_device_id *id, char *alias)
|
|
|
|
{
|
|
|
|
id->match_flags = TO_NATIVE(id->match_flags);
|
|
|
|
id->vendor_id = TO_NATIVE(id->vendor_id);
|
|
|
|
id->model_id = TO_NATIVE(id->model_id);
|
|
|
|
id->specifier_id = TO_NATIVE(id->specifier_id);
|
|
|
|
id->version = TO_NATIVE(id->version);
|
|
|
|
|
|
|
|
strcpy(alias, "ieee1394:");
|
|
|
|
ADD(alias, "ven", id->match_flags & IEEE1394_MATCH_VENDOR_ID,
|
|
|
|
id->vendor_id);
|
|
|
|
ADD(alias, "mo", id->match_flags & IEEE1394_MATCH_MODEL_ID,
|
|
|
|
id->model_id);
|
|
|
|
ADD(alias, "sp", id->match_flags & IEEE1394_MATCH_SPECIFIER_ID,
|
|
|
|
id->specifier_id);
|
|
|
|
ADD(alias, "ver", id->match_flags & IEEE1394_MATCH_VERSION,
|
|
|
|
id->version);
|
|
|
|
|
modpost: i2c aliases need no trailing wildcard
Not all device types need a wildcard at the end of their module
aliases. In particular, for i2c module aliases, the trailing wildcard
is not only unneeded, it could also cause the wrong driver to be
loaded.
As I2C devices have no IDs, i2c module aliases are simple, arbitrary
device names. For example:
$ /sbin/modinfo lm90
filename: /lib/modules/2.6.25-git18/kernel/drivers/hwmon/lm90.ko
author: Jean Delvare <khali@linux-fr.org>
description: LM90/ADM1032 driver
license: GPL
vermagic: 2.6.25-git18 mod_unload
depends: hwmon
alias: i2c:lm90*
alias: i2c:adm1032*
alias: i2c:lm99*
alias: i2c:lm86*
alias: i2c:max6657*
alias: i2c:adt7461*
alias: i2c:max6680*
$
This would cause trouble if one I2C chip name matches the beginning of
another I2C chip name and both chips are supported by different
drivers. For example, an i2c device named lm9042 would cause the lm90
driver to be loaded, while it doesn't support that device. This case
has yet to be seen in practice, but still, I'd like to fix it now. The
cleanest fix is to remove the trailing wildcard from i2c module aliases.
Here's a patch doing this.
Not all device type aliases need a trailing wildcard, in particular
the i2c aliases don't. Don't add a wildcard by default in do_table(),
instead let each device type handler add it if needed.
I have tested types acpi, dmi, eisa, i2c, ide, ieee1394, input, pci,
pcmcia, platform, pnp, scsi, serio, ssb and usb. Other types (ccw, of,
vio, parisc, sdio and virtio) are untested.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Acked-by: Jochen Friedrich <jochen@scram.de>
Signed-off-by: Sam Ravnborg <sam@ravnborg.org>
2008-05-02 20:37:21 +02:00
|
|
|
add_wildcard(alias);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Looks like: pci:vNdNsvNsdNbcNscNiN. */
|
|
|
|
static int do_pci_entry(const char *filename,
|
|
|
|
struct pci_device_id *id, char *alias)
|
|
|
|
{
|
|
|
|
/* Class field can be divided into these three. */
|
|
|
|
unsigned char baseclass, subclass, interface,
|
|
|
|
baseclass_mask, subclass_mask, interface_mask;
|
|
|
|
|
|
|
|
id->vendor = TO_NATIVE(id->vendor);
|
|
|
|
id->device = TO_NATIVE(id->device);
|
|
|
|
id->subvendor = TO_NATIVE(id->subvendor);
|
|
|
|
id->subdevice = TO_NATIVE(id->subdevice);
|
|
|
|
id->class = TO_NATIVE(id->class);
|
|
|
|
id->class_mask = TO_NATIVE(id->class_mask);
|
|
|
|
|
|
|
|
strcpy(alias, "pci:");
|
|
|
|
ADD(alias, "v", id->vendor != PCI_ANY_ID, id->vendor);
|
|
|
|
ADD(alias, "d", id->device != PCI_ANY_ID, id->device);
|
|
|
|
ADD(alias, "sv", id->subvendor != PCI_ANY_ID, id->subvendor);
|
|
|
|
ADD(alias, "sd", id->subdevice != PCI_ANY_ID, id->subdevice);
|
|
|
|
|
|
|
|
baseclass = (id->class) >> 16;
|
|
|
|
baseclass_mask = (id->class_mask) >> 16;
|
|
|
|
subclass = (id->class) >> 8;
|
|
|
|
subclass_mask = (id->class_mask) >> 8;
|
|
|
|
interface = id->class;
|
|
|
|
interface_mask = id->class_mask;
|
|
|
|
|
|
|
|
if ((baseclass_mask != 0 && baseclass_mask != 0xFF)
|
|
|
|
|| (subclass_mask != 0 && subclass_mask != 0xFF)
|
|
|
|
|| (interface_mask != 0 && interface_mask != 0xFF)) {
|
2006-01-28 16:57:26 +01:00
|
|
|
warn("Can't handle masks in %s:%04X\n",
|
|
|
|
filename, id->class_mask);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
ADD(alias, "bc", baseclass_mask == 0xFF, baseclass);
|
|
|
|
ADD(alias, "sc", subclass_mask == 0xFF, subclass);
|
|
|
|
ADD(alias, "i", interface_mask == 0xFF, interface);
|
modpost: i2c aliases need no trailing wildcard
Not all device types need a wildcard at the end of their module
aliases. In particular, for i2c module aliases, the trailing wildcard
is not only unneeded, it could also cause the wrong driver to be
loaded.
As I2C devices have no IDs, i2c module aliases are simple, arbitrary
device names. For example:
$ /sbin/modinfo lm90
filename: /lib/modules/2.6.25-git18/kernel/drivers/hwmon/lm90.ko
author: Jean Delvare <khali@linux-fr.org>
description: LM90/ADM1032 driver
license: GPL
vermagic: 2.6.25-git18 mod_unload
depends: hwmon
alias: i2c:lm90*
alias: i2c:adm1032*
alias: i2c:lm99*
alias: i2c:lm86*
alias: i2c:max6657*
alias: i2c:adt7461*
alias: i2c:max6680*
$
This would cause trouble if one I2C chip name matches the beginning of
another I2C chip name and both chips are supported by different
drivers. For example, an i2c device named lm9042 would cause the lm90
driver to be loaded, while it doesn't support that device. This case
has yet to be seen in practice, but still, I'd like to fix it now. The
cleanest fix is to remove the trailing wildcard from i2c module aliases.
Here's a patch doing this.
Not all device type aliases need a trailing wildcard, in particular
the i2c aliases don't. Don't add a wildcard by default in do_table(),
instead let each device type handler add it if needed.
I have tested types acpi, dmi, eisa, i2c, ide, ieee1394, input, pci,
pcmcia, platform, pnp, scsi, serio, ssb and usb. Other types (ccw, of,
vio, parisc, sdio and virtio) are untested.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Acked-by: Jochen Friedrich <jochen@scram.de>
Signed-off-by: Sam Ravnborg <sam@ravnborg.org>
2008-05-02 20:37:21 +02:00
|
|
|
add_wildcard(alias);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2006-03-03 16:46:04 +01:00
|
|
|
/* looks like: "ccw:tNmNdtNdmN" */
|
2005-04-17 00:20:36 +02:00
|
|
|
static int do_ccw_entry(const char *filename,
|
|
|
|
struct ccw_device_id *id, char *alias)
|
|
|
|
{
|
|
|
|
id->match_flags = TO_NATIVE(id->match_flags);
|
|
|
|
id->cu_type = TO_NATIVE(id->cu_type);
|
|
|
|
id->cu_model = TO_NATIVE(id->cu_model);
|
|
|
|
id->dev_type = TO_NATIVE(id->dev_type);
|
|
|
|
id->dev_model = TO_NATIVE(id->dev_model);
|
|
|
|
|
|
|
|
strcpy(alias, "ccw:");
|
|
|
|
ADD(alias, "t", id->match_flags&CCW_DEVICE_ID_MATCH_CU_TYPE,
|
|
|
|
id->cu_type);
|
|
|
|
ADD(alias, "m", id->match_flags&CCW_DEVICE_ID_MATCH_CU_MODEL,
|
|
|
|
id->cu_model);
|
|
|
|
ADD(alias, "dt", id->match_flags&CCW_DEVICE_ID_MATCH_DEVICE_TYPE,
|
|
|
|
id->dev_type);
|
2006-03-07 00:43:00 +01:00
|
|
|
ADD(alias, "dm", id->match_flags&CCW_DEVICE_ID_MATCH_DEVICE_MODEL,
|
2005-04-17 00:20:36 +02:00
|
|
|
id->dev_model);
|
modpost: i2c aliases need no trailing wildcard
Not all device types need a wildcard at the end of their module
aliases. In particular, for i2c module aliases, the trailing wildcard
is not only unneeded, it could also cause the wrong driver to be
loaded.
As I2C devices have no IDs, i2c module aliases are simple, arbitrary
device names. For example:
$ /sbin/modinfo lm90
filename: /lib/modules/2.6.25-git18/kernel/drivers/hwmon/lm90.ko
author: Jean Delvare <khali@linux-fr.org>
description: LM90/ADM1032 driver
license: GPL
vermagic: 2.6.25-git18 mod_unload
depends: hwmon
alias: i2c:lm90*
alias: i2c:adm1032*
alias: i2c:lm99*
alias: i2c:lm86*
alias: i2c:max6657*
alias: i2c:adt7461*
alias: i2c:max6680*
$
This would cause trouble if one I2C chip name matches the beginning of
another I2C chip name and both chips are supported by different
drivers. For example, an i2c device named lm9042 would cause the lm90
driver to be loaded, while it doesn't support that device. This case
has yet to be seen in practice, but still, I'd like to fix it now. The
cleanest fix is to remove the trailing wildcard from i2c module aliases.
Here's a patch doing this.
Not all device type aliases need a trailing wildcard, in particular
the i2c aliases don't. Don't add a wildcard by default in do_table(),
instead let each device type handler add it if needed.
I have tested types acpi, dmi, eisa, i2c, ide, ieee1394, input, pci,
pcmcia, platform, pnp, scsi, serio, ssb and usb. Other types (ccw, of,
vio, parisc, sdio and virtio) are untested.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Acked-by: Jochen Friedrich <jochen@scram.de>
Signed-off-by: Sam Ravnborg <sam@ravnborg.org>
2008-05-02 20:37:21 +02:00
|
|
|
add_wildcard(alias);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2006-09-20 15:58:25 +02:00
|
|
|
/* looks like: "ap:tN" */
|
|
|
|
static int do_ap_entry(const char *filename,
|
|
|
|
struct ap_device_id *id, char *alias)
|
|
|
|
{
|
modpost: i2c aliases need no trailing wildcard
Not all device types need a wildcard at the end of their module
aliases. In particular, for i2c module aliases, the trailing wildcard
is not only unneeded, it could also cause the wrong driver to be
loaded.
As I2C devices have no IDs, i2c module aliases are simple, arbitrary
device names. For example:
$ /sbin/modinfo lm90
filename: /lib/modules/2.6.25-git18/kernel/drivers/hwmon/lm90.ko
author: Jean Delvare <khali@linux-fr.org>
description: LM90/ADM1032 driver
license: GPL
vermagic: 2.6.25-git18 mod_unload
depends: hwmon
alias: i2c:lm90*
alias: i2c:adm1032*
alias: i2c:lm99*
alias: i2c:lm86*
alias: i2c:max6657*
alias: i2c:adt7461*
alias: i2c:max6680*
$
This would cause trouble if one I2C chip name matches the beginning of
another I2C chip name and both chips are supported by different
drivers. For example, an i2c device named lm9042 would cause the lm90
driver to be loaded, while it doesn't support that device. This case
has yet to be seen in practice, but still, I'd like to fix it now. The
cleanest fix is to remove the trailing wildcard from i2c module aliases.
Here's a patch doing this.
Not all device type aliases need a trailing wildcard, in particular
the i2c aliases don't. Don't add a wildcard by default in do_table(),
instead let each device type handler add it if needed.
I have tested types acpi, dmi, eisa, i2c, ide, ieee1394, input, pci,
pcmcia, platform, pnp, scsi, serio, ssb and usb. Other types (ccw, of,
vio, parisc, sdio and virtio) are untested.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Acked-by: Jochen Friedrich <jochen@scram.de>
Signed-off-by: Sam Ravnborg <sam@ravnborg.org>
2008-05-02 20:37:21 +02:00
|
|
|
sprintf(alias, "ap:t%02X*", id->dev_type);
|
2006-09-20 15:58:25 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-07-14 09:58:44 +02:00
|
|
|
/* looks like: "css:tN" */
|
|
|
|
static int do_css_entry(const char *filename,
|
|
|
|
struct css_device_id *id, char *alias)
|
|
|
|
{
|
|
|
|
sprintf(alias, "css:t%01X", id->type);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Looks like: "serio:tyNprNidNexN" */
|
|
|
|
static int do_serio_entry(const char *filename,
|
|
|
|
struct serio_device_id *id, char *alias)
|
|
|
|
{
|
|
|
|
id->type = TO_NATIVE(id->type);
|
|
|
|
id->proto = TO_NATIVE(id->proto);
|
|
|
|
id->id = TO_NATIVE(id->id);
|
|
|
|
id->extra = TO_NATIVE(id->extra);
|
|
|
|
|
|
|
|
strcpy(alias, "serio:");
|
|
|
|
ADD(alias, "ty", id->type != SERIO_ANY, id->type);
|
|
|
|
ADD(alias, "pr", id->proto != SERIO_ANY, id->proto);
|
|
|
|
ADD(alias, "id", id->id != SERIO_ANY, id->id);
|
|
|
|
ADD(alias, "ex", id->extra != SERIO_ANY, id->extra);
|
|
|
|
|
modpost: i2c aliases need no trailing wildcard
Not all device types need a wildcard at the end of their module
aliases. In particular, for i2c module aliases, the trailing wildcard
is not only unneeded, it could also cause the wrong driver to be
loaded.
As I2C devices have no IDs, i2c module aliases are simple, arbitrary
device names. For example:
$ /sbin/modinfo lm90
filename: /lib/modules/2.6.25-git18/kernel/drivers/hwmon/lm90.ko
author: Jean Delvare <khali@linux-fr.org>
description: LM90/ADM1032 driver
license: GPL
vermagic: 2.6.25-git18 mod_unload
depends: hwmon
alias: i2c:lm90*
alias: i2c:adm1032*
alias: i2c:lm99*
alias: i2c:lm86*
alias: i2c:max6657*
alias: i2c:adt7461*
alias: i2c:max6680*
$
This would cause trouble if one I2C chip name matches the beginning of
another I2C chip name and both chips are supported by different
drivers. For example, an i2c device named lm9042 would cause the lm90
driver to be loaded, while it doesn't support that device. This case
has yet to be seen in practice, but still, I'd like to fix it now. The
cleanest fix is to remove the trailing wildcard from i2c module aliases.
Here's a patch doing this.
Not all device type aliases need a trailing wildcard, in particular
the i2c aliases don't. Don't add a wildcard by default in do_table(),
instead let each device type handler add it if needed.
I have tested types acpi, dmi, eisa, i2c, ide, ieee1394, input, pci,
pcmcia, platform, pnp, scsi, serio, ssb and usb. Other types (ccw, of,
vio, parisc, sdio and virtio) are untested.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Acked-by: Jochen Friedrich <jochen@scram.de>
Signed-off-by: Sam Ravnborg <sam@ravnborg.org>
2008-05-02 20:37:21 +02:00
|
|
|
add_wildcard(alias);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-07-23 14:43:51 +02:00
|
|
|
/* looks like: "acpi:ACPI0003 or acpi:PNP0C0B" or "acpi:LNXVIDEO" */
|
|
|
|
static int do_acpi_entry(const char *filename,
|
|
|
|
struct acpi_device_id *id, char *alias)
|
|
|
|
{
|
modpost: i2c aliases need no trailing wildcard
Not all device types need a wildcard at the end of their module
aliases. In particular, for i2c module aliases, the trailing wildcard
is not only unneeded, it could also cause the wrong driver to be
loaded.
As I2C devices have no IDs, i2c module aliases are simple, arbitrary
device names. For example:
$ /sbin/modinfo lm90
filename: /lib/modules/2.6.25-git18/kernel/drivers/hwmon/lm90.ko
author: Jean Delvare <khali@linux-fr.org>
description: LM90/ADM1032 driver
license: GPL
vermagic: 2.6.25-git18 mod_unload
depends: hwmon
alias: i2c:lm90*
alias: i2c:adm1032*
alias: i2c:lm99*
alias: i2c:lm86*
alias: i2c:max6657*
alias: i2c:adt7461*
alias: i2c:max6680*
$
This would cause trouble if one I2C chip name matches the beginning of
another I2C chip name and both chips are supported by different
drivers. For example, an i2c device named lm9042 would cause the lm90
driver to be loaded, while it doesn't support that device. This case
has yet to be seen in practice, but still, I'd like to fix it now. The
cleanest fix is to remove the trailing wildcard from i2c module aliases.
Here's a patch doing this.
Not all device type aliases need a trailing wildcard, in particular
the i2c aliases don't. Don't add a wildcard by default in do_table(),
instead let each device type handler add it if needed.
I have tested types acpi, dmi, eisa, i2c, ide, ieee1394, input, pci,
pcmcia, platform, pnp, scsi, serio, ssb and usb. Other types (ccw, of,
vio, parisc, sdio and virtio) are untested.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Acked-by: Jochen Friedrich <jochen@scram.de>
Signed-off-by: Sam Ravnborg <sam@ravnborg.org>
2008-05-02 20:37:21 +02:00
|
|
|
sprintf(alias, "acpi*:%s:*", id->id);
|
2007-07-23 14:43:51 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* looks like: "pnp:dD" */
|
|
|
|
static int do_pnp_entry(const char *filename,
|
|
|
|
struct pnp_device_id *id, char *alias)
|
|
|
|
{
|
modpost: i2c aliases need no trailing wildcard
Not all device types need a wildcard at the end of their module
aliases. In particular, for i2c module aliases, the trailing wildcard
is not only unneeded, it could also cause the wrong driver to be
loaded.
As I2C devices have no IDs, i2c module aliases are simple, arbitrary
device names. For example:
$ /sbin/modinfo lm90
filename: /lib/modules/2.6.25-git18/kernel/drivers/hwmon/lm90.ko
author: Jean Delvare <khali@linux-fr.org>
description: LM90/ADM1032 driver
license: GPL
vermagic: 2.6.25-git18 mod_unload
depends: hwmon
alias: i2c:lm90*
alias: i2c:adm1032*
alias: i2c:lm99*
alias: i2c:lm86*
alias: i2c:max6657*
alias: i2c:adt7461*
alias: i2c:max6680*
$
This would cause trouble if one I2C chip name matches the beginning of
another I2C chip name and both chips are supported by different
drivers. For example, an i2c device named lm9042 would cause the lm90
driver to be loaded, while it doesn't support that device. This case
has yet to be seen in practice, but still, I'd like to fix it now. The
cleanest fix is to remove the trailing wildcard from i2c module aliases.
Here's a patch doing this.
Not all device type aliases need a trailing wildcard, in particular
the i2c aliases don't. Don't add a wildcard by default in do_table(),
instead let each device type handler add it if needed.
I have tested types acpi, dmi, eisa, i2c, ide, ieee1394, input, pci,
pcmcia, platform, pnp, scsi, serio, ssb and usb. Other types (ccw, of,
vio, parisc, sdio and virtio) are untested.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Acked-by: Jochen Friedrich <jochen@scram.de>
Signed-off-by: Sam Ravnborg <sam@ravnborg.org>
2008-05-02 20:37:21 +02:00
|
|
|
sprintf(alias, "pnp:d%s*", id->id);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-02-21 00:35:54 +01:00
|
|
|
/* looks like: "pnp:dD" for every device of the card */
|
|
|
|
static void do_pnp_card_entries(void *symval, unsigned long size,
|
|
|
|
struct module *mod)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-02-21 00:35:54 +01:00
|
|
|
const unsigned long id_size = sizeof(struct pnp_card_device_id);
|
|
|
|
const unsigned int count = (size / id_size)-1;
|
|
|
|
const struct pnp_card_device_id *cards = symval;
|
|
|
|
unsigned int i;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-02-21 00:35:54 +01:00
|
|
|
device_id_check(mod->name, "pnp", size, id_size, symval);
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
unsigned int j;
|
|
|
|
const struct pnp_card_device_id *card = &cards[i];
|
|
|
|
|
|
|
|
for (j = 0; j < PNP_MAX_DEVICES; j++) {
|
|
|
|
const char *id = (char *)card->devs[j].id;
|
|
|
|
int i2, j2;
|
|
|
|
int dup = 0;
|
|
|
|
|
|
|
|
if (!id[0])
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* find duplicate, already added value */
|
|
|
|
for (i2 = 0; i2 < i && !dup; i2++) {
|
|
|
|
const struct pnp_card_device_id *card2 = &cards[i2];
|
|
|
|
|
|
|
|
for (j2 = 0; j2 < PNP_MAX_DEVICES; j2++) {
|
|
|
|
const char *id2 = (char *)card2->devs[j2].id;
|
|
|
|
|
|
|
|
if (!id2[0])
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (!strcmp(id, id2)) {
|
|
|
|
dup = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* add an individual alias for every device entry */
|
|
|
|
if (!dup)
|
|
|
|
buf_printf(&mod->dev_table_buf,
|
|
|
|
"MODULE_ALIAS(\"pnp:d%s*\");\n", id);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-06-28 01:28:12 +02:00
|
|
|
/* Looks like: pcmcia:mNcNfNfnNpfnNvaNvbNvcNvdN. */
|
|
|
|
static int do_pcmcia_entry(const char *filename,
|
|
|
|
struct pcmcia_device_id *id, char *alias)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
|
2005-09-25 14:39:46 +02:00
|
|
|
id->match_flags = TO_NATIVE(id->match_flags);
|
2005-06-28 01:28:12 +02:00
|
|
|
id->manf_id = TO_NATIVE(id->manf_id);
|
|
|
|
id->card_id = TO_NATIVE(id->card_id);
|
|
|
|
id->func_id = TO_NATIVE(id->func_id);
|
|
|
|
id->function = TO_NATIVE(id->function);
|
|
|
|
id->device_no = TO_NATIVE(id->device_no);
|
2005-09-25 14:39:46 +02:00
|
|
|
|
2005-06-28 01:28:12 +02:00
|
|
|
for (i=0; i<4; i++) {
|
|
|
|
id->prod_id_hash[i] = TO_NATIVE(id->prod_id_hash[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
strcpy(alias, "pcmcia:");
|
|
|
|
ADD(alias, "m", id->match_flags & PCMCIA_DEV_ID_MATCH_MANF_ID,
|
|
|
|
id->manf_id);
|
|
|
|
ADD(alias, "c", id->match_flags & PCMCIA_DEV_ID_MATCH_CARD_ID,
|
|
|
|
id->card_id);
|
|
|
|
ADD(alias, "f", id->match_flags & PCMCIA_DEV_ID_MATCH_FUNC_ID,
|
|
|
|
id->func_id);
|
|
|
|
ADD(alias, "fn", id->match_flags & PCMCIA_DEV_ID_MATCH_FUNCTION,
|
|
|
|
id->function);
|
|
|
|
ADD(alias, "pfn", id->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO,
|
|
|
|
id->device_no);
|
|
|
|
ADD(alias, "pa", id->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID1, id->prod_id_hash[0]);
|
|
|
|
ADD(alias, "pb", id->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID2, id->prod_id_hash[1]);
|
|
|
|
ADD(alias, "pc", id->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID3, id->prod_id_hash[2]);
|
|
|
|
ADD(alias, "pd", id->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID4, id->prod_id_hash[3]);
|
|
|
|
|
modpost: i2c aliases need no trailing wildcard
Not all device types need a wildcard at the end of their module
aliases. In particular, for i2c module aliases, the trailing wildcard
is not only unneeded, it could also cause the wrong driver to be
loaded.
As I2C devices have no IDs, i2c module aliases are simple, arbitrary
device names. For example:
$ /sbin/modinfo lm90
filename: /lib/modules/2.6.25-git18/kernel/drivers/hwmon/lm90.ko
author: Jean Delvare <khali@linux-fr.org>
description: LM90/ADM1032 driver
license: GPL
vermagic: 2.6.25-git18 mod_unload
depends: hwmon
alias: i2c:lm90*
alias: i2c:adm1032*
alias: i2c:lm99*
alias: i2c:lm86*
alias: i2c:max6657*
alias: i2c:adt7461*
alias: i2c:max6680*
$
This would cause trouble if one I2C chip name matches the beginning of
another I2C chip name and both chips are supported by different
drivers. For example, an i2c device named lm9042 would cause the lm90
driver to be loaded, while it doesn't support that device. This case
has yet to be seen in practice, but still, I'd like to fix it now. The
cleanest fix is to remove the trailing wildcard from i2c module aliases.
Here's a patch doing this.
Not all device type aliases need a trailing wildcard, in particular
the i2c aliases don't. Don't add a wildcard by default in do_table(),
instead let each device type handler add it if needed.
I have tested types acpi, dmi, eisa, i2c, ide, ieee1394, input, pci,
pcmcia, platform, pnp, scsi, serio, ssb and usb. Other types (ccw, of,
vio, parisc, sdio and virtio) are untested.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Acked-by: Jochen Friedrich <jochen@scram.de>
Signed-off-by: Sam Ravnborg <sam@ravnborg.org>
2008-05-02 20:37:21 +02:00
|
|
|
add_wildcard(alias);
|
2005-06-28 01:28:12 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2005-07-06 21:44:41 +02:00
|
|
|
static int do_of_entry (const char *filename, struct of_device_id *of, char *alias)
|
|
|
|
{
|
2007-05-08 11:59:29 +02:00
|
|
|
int len;
|
2005-07-06 21:44:41 +02:00
|
|
|
char *tmp;
|
2007-05-08 11:59:29 +02:00
|
|
|
len = sprintf (alias, "of:N%sT%s",
|
2005-07-06 21:44:41 +02:00
|
|
|
of->name[0] ? of->name : "*",
|
2007-05-08 11:59:29 +02:00
|
|
|
of->type[0] ? of->type : "*");
|
|
|
|
|
|
|
|
if (of->compatible[0])
|
|
|
|
sprintf (&alias[len], "%sC%s",
|
|
|
|
of->type[0] ? "*" : "",
|
|
|
|
of->compatible);
|
2005-07-06 21:44:41 +02:00
|
|
|
|
|
|
|
/* Replace all whitespace with underscores */
|
|
|
|
for (tmp = alias; tmp && *tmp; tmp++)
|
|
|
|
if (isspace (*tmp))
|
|
|
|
*tmp = '_';
|
|
|
|
|
modpost: i2c aliases need no trailing wildcard
Not all device types need a wildcard at the end of their module
aliases. In particular, for i2c module aliases, the trailing wildcard
is not only unneeded, it could also cause the wrong driver to be
loaded.
As I2C devices have no IDs, i2c module aliases are simple, arbitrary
device names. For example:
$ /sbin/modinfo lm90
filename: /lib/modules/2.6.25-git18/kernel/drivers/hwmon/lm90.ko
author: Jean Delvare <khali@linux-fr.org>
description: LM90/ADM1032 driver
license: GPL
vermagic: 2.6.25-git18 mod_unload
depends: hwmon
alias: i2c:lm90*
alias: i2c:adm1032*
alias: i2c:lm99*
alias: i2c:lm86*
alias: i2c:max6657*
alias: i2c:adt7461*
alias: i2c:max6680*
$
This would cause trouble if one I2C chip name matches the beginning of
another I2C chip name and both chips are supported by different
drivers. For example, an i2c device named lm9042 would cause the lm90
driver to be loaded, while it doesn't support that device. This case
has yet to be seen in practice, but still, I'd like to fix it now. The
cleanest fix is to remove the trailing wildcard from i2c module aliases.
Here's a patch doing this.
Not all device type aliases need a trailing wildcard, in particular
the i2c aliases don't. Don't add a wildcard by default in do_table(),
instead let each device type handler add it if needed.
I have tested types acpi, dmi, eisa, i2c, ide, ieee1394, input, pci,
pcmcia, platform, pnp, scsi, serio, ssb and usb. Other types (ccw, of,
vio, parisc, sdio and virtio) are untested.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Acked-by: Jochen Friedrich <jochen@scram.de>
Signed-off-by: Sam Ravnborg <sam@ravnborg.org>
2008-05-02 20:37:21 +02:00
|
|
|
add_wildcard(alias);
|
2005-07-06 21:44:41 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2005-08-17 08:42:59 +02:00
|
|
|
static int do_vio_entry(const char *filename, struct vio_device_id *vio,
|
|
|
|
char *alias)
|
|
|
|
{
|
|
|
|
char *tmp;
|
|
|
|
|
|
|
|
sprintf(alias, "vio:T%sS%s", vio->type[0] ? vio->type : "*",
|
|
|
|
vio->compat[0] ? vio->compat : "*");
|
|
|
|
|
|
|
|
/* Replace all whitespace with underscores */
|
|
|
|
for (tmp = alias; tmp && *tmp; tmp++)
|
|
|
|
if (isspace (*tmp))
|
|
|
|
*tmp = '_';
|
|
|
|
|
modpost: i2c aliases need no trailing wildcard
Not all device types need a wildcard at the end of their module
aliases. In particular, for i2c module aliases, the trailing wildcard
is not only unneeded, it could also cause the wrong driver to be
loaded.
As I2C devices have no IDs, i2c module aliases are simple, arbitrary
device names. For example:
$ /sbin/modinfo lm90
filename: /lib/modules/2.6.25-git18/kernel/drivers/hwmon/lm90.ko
author: Jean Delvare <khali@linux-fr.org>
description: LM90/ADM1032 driver
license: GPL
vermagic: 2.6.25-git18 mod_unload
depends: hwmon
alias: i2c:lm90*
alias: i2c:adm1032*
alias: i2c:lm99*
alias: i2c:lm86*
alias: i2c:max6657*
alias: i2c:adt7461*
alias: i2c:max6680*
$
This would cause trouble if one I2C chip name matches the beginning of
another I2C chip name and both chips are supported by different
drivers. For example, an i2c device named lm9042 would cause the lm90
driver to be loaded, while it doesn't support that device. This case
has yet to be seen in practice, but still, I'd like to fix it now. The
cleanest fix is to remove the trailing wildcard from i2c module aliases.
Here's a patch doing this.
Not all device type aliases need a trailing wildcard, in particular
the i2c aliases don't. Don't add a wildcard by default in do_table(),
instead let each device type handler add it if needed.
I have tested types acpi, dmi, eisa, i2c, ide, ieee1394, input, pci,
pcmcia, platform, pnp, scsi, serio, ssb and usb. Other types (ccw, of,
vio, parisc, sdio and virtio) are untested.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Acked-by: Jochen Friedrich <jochen@scram.de>
Signed-off-by: Sam Ravnborg <sam@ravnborg.org>
2008-05-02 20:37:21 +02:00
|
|
|
add_wildcard(alias);
|
2005-08-17 08:42:59 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2005-12-07 21:40:34 +01:00
|
|
|
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
|
|
|
|
|
|
|
|
static void do_input(char *alias,
|
|
|
|
kernel_ulong_t *arr, unsigned int min, unsigned int max)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
2006-04-26 06:14:19 +02:00
|
|
|
|
|
|
|
for (i = min; i < max; i++)
|
[PATCH] PATCH: 1 line 2.6.18 bugfix: modpost-64bit-fix.patch
There is a small but annoying bug in scripts/mod/file2alias.c which causes
it to generate invalid aliases for input devices on 64 bit archs. This causes
joydev.ko to not be automaticly loaded when inserting a joystick, resulting in
a non working joystick (for the average user).
In scripts/mod/file2alias.c is the following code for generating the input
aliases:
static void do_input(char *alias,
kernel_ulong_t *arr, unsigned int min, unsigned int max)
{
unsigned int i;
for (i = min; i < max; i++)
if (arr[i / BITS_PER_LONG] & (1 << (i%BITS_PER_LONG)))
sprintf(alias + strlen(alias), "%X,*", i);
}
On 32 bits systems, this correctly generates "0,*" for the first alias, "8,*"
for the second etc.
However on 64 bits it generates: "0,*20,*" resp "8,*28,*" Notice how it adds 20
+ first entry (hex) ! to the list of hex codes, which is 32 more then the first
entry, thus is because the bit test above wraps at 32 bits instead of 64.
scripts/mod/file2alias.c, line 379 reads:
if (arr[i / BITS_PER_LONG] & (1 << (i%BITS_PER_LONG)))
That should be:
if (arr[i / BITS_PER_LONG] & (1L << (i%BITS_PER_LONG)))
Notice the added 'L' after the 1, otherwise that is an 32 bit int instead of a
64 bit long, and when that int gets shifted >= 32 times, appearantly the number
by which to shift is wrapped at 5 bits ( % 32) causing it to test a bit 32 bits
too low.
The patch below makes the nescesarry 1 char change :)
Signed-off-by: Hans de Goede <j.w.r.degoede@hhs.nl>
Acked-by: Rusty Russell <rusty@rustcorp.com.au>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2006-08-15 12:09:27 +02:00
|
|
|
if (arr[i / BITS_PER_LONG] & (1L << (i%BITS_PER_LONG)))
|
2006-04-26 06:14:19 +02:00
|
|
|
sprintf(alias + strlen(alias), "%X,*", i);
|
2005-12-07 21:40:34 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* input:b0v0p0e0-eXkXrXaXmXlXsXfXwX where X is comma-separated %02X. */
|
|
|
|
static int do_input_entry(const char *filename, struct input_device_id *id,
|
|
|
|
char *alias)
|
|
|
|
{
|
|
|
|
sprintf(alias, "input:");
|
|
|
|
|
2006-04-26 06:14:19 +02:00
|
|
|
ADD(alias, "b", id->flags & INPUT_DEVICE_ID_MATCH_BUS, id->bustype);
|
|
|
|
ADD(alias, "v", id->flags & INPUT_DEVICE_ID_MATCH_VENDOR, id->vendor);
|
|
|
|
ADD(alias, "p", id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT, id->product);
|
|
|
|
ADD(alias, "e", id->flags & INPUT_DEVICE_ID_MATCH_VERSION, id->version);
|
2005-12-07 21:40:34 +01:00
|
|
|
|
|
|
|
sprintf(alias + strlen(alias), "-e*");
|
2006-04-26 06:14:19 +02:00
|
|
|
if (id->flags & INPUT_DEVICE_ID_MATCH_EVBIT)
|
2007-03-09 19:59:06 +01:00
|
|
|
do_input(alias, id->evbit, 0, INPUT_DEVICE_ID_EV_MAX);
|
2005-12-07 21:40:34 +01:00
|
|
|
sprintf(alias + strlen(alias), "k*");
|
2006-04-26 06:14:19 +02:00
|
|
|
if (id->flags & INPUT_DEVICE_ID_MATCH_KEYBIT)
|
2007-03-09 19:59:06 +01:00
|
|
|
do_input(alias, id->keybit,
|
|
|
|
INPUT_DEVICE_ID_KEY_MIN_INTERESTING,
|
|
|
|
INPUT_DEVICE_ID_KEY_MAX);
|
2005-12-07 21:40:34 +01:00
|
|
|
sprintf(alias + strlen(alias), "r*");
|
2006-04-26 06:14:19 +02:00
|
|
|
if (id->flags & INPUT_DEVICE_ID_MATCH_RELBIT)
|
2007-03-09 19:59:06 +01:00
|
|
|
do_input(alias, id->relbit, 0, INPUT_DEVICE_ID_REL_MAX);
|
2005-12-07 21:40:34 +01:00
|
|
|
sprintf(alias + strlen(alias), "a*");
|
2006-04-26 06:14:19 +02:00
|
|
|
if (id->flags & INPUT_DEVICE_ID_MATCH_ABSBIT)
|
2007-03-09 19:59:06 +01:00
|
|
|
do_input(alias, id->absbit, 0, INPUT_DEVICE_ID_ABS_MAX);
|
2005-12-07 21:40:34 +01:00
|
|
|
sprintf(alias + strlen(alias), "m*");
|
2006-04-26 06:14:19 +02:00
|
|
|
if (id->flags & INPUT_DEVICE_ID_MATCH_MSCIT)
|
2007-03-09 19:59:06 +01:00
|
|
|
do_input(alias, id->mscbit, 0, INPUT_DEVICE_ID_MSC_MAX);
|
2005-12-07 21:40:34 +01:00
|
|
|
sprintf(alias + strlen(alias), "l*");
|
2006-04-26 06:14:19 +02:00
|
|
|
if (id->flags & INPUT_DEVICE_ID_MATCH_LEDBIT)
|
2007-03-09 19:59:06 +01:00
|
|
|
do_input(alias, id->ledbit, 0, INPUT_DEVICE_ID_LED_MAX);
|
2005-12-07 21:40:34 +01:00
|
|
|
sprintf(alias + strlen(alias), "s*");
|
2006-04-26 06:14:19 +02:00
|
|
|
if (id->flags & INPUT_DEVICE_ID_MATCH_SNDBIT)
|
2007-03-09 19:59:06 +01:00
|
|
|
do_input(alias, id->sndbit, 0, INPUT_DEVICE_ID_SND_MAX);
|
2005-12-07 21:40:34 +01:00
|
|
|
sprintf(alias + strlen(alias), "f*");
|
2006-04-26 06:14:19 +02:00
|
|
|
if (id->flags & INPUT_DEVICE_ID_MATCH_FFBIT)
|
2007-03-09 19:59:06 +01:00
|
|
|
do_input(alias, id->ffbit, 0, INPUT_DEVICE_ID_FF_MAX);
|
2005-12-07 21:40:34 +01:00
|
|
|
sprintf(alias + strlen(alias), "w*");
|
2006-04-26 06:14:19 +02:00
|
|
|
if (id->flags & INPUT_DEVICE_ID_MATCH_SWBIT)
|
2007-03-09 19:59:06 +01:00
|
|
|
do_input(alias, id->swbit, 0, INPUT_DEVICE_ID_SW_MAX);
|
2005-12-07 21:40:34 +01:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2006-09-27 10:50:56 +02:00
|
|
|
static int do_eisa_entry(const char *filename, struct eisa_device_id *eisa,
|
|
|
|
char *alias)
|
|
|
|
{
|
|
|
|
if (eisa->sig[0])
|
|
|
|
sprintf(alias, EISA_DEVICE_MODALIAS_FMT "*", eisa->sig);
|
modpost: i2c aliases need no trailing wildcard
Not all device types need a wildcard at the end of their module
aliases. In particular, for i2c module aliases, the trailing wildcard
is not only unneeded, it could also cause the wrong driver to be
loaded.
As I2C devices have no IDs, i2c module aliases are simple, arbitrary
device names. For example:
$ /sbin/modinfo lm90
filename: /lib/modules/2.6.25-git18/kernel/drivers/hwmon/lm90.ko
author: Jean Delvare <khali@linux-fr.org>
description: LM90/ADM1032 driver
license: GPL
vermagic: 2.6.25-git18 mod_unload
depends: hwmon
alias: i2c:lm90*
alias: i2c:adm1032*
alias: i2c:lm99*
alias: i2c:lm86*
alias: i2c:max6657*
alias: i2c:adt7461*
alias: i2c:max6680*
$
This would cause trouble if one I2C chip name matches the beginning of
another I2C chip name and both chips are supported by different
drivers. For example, an i2c device named lm9042 would cause the lm90
driver to be loaded, while it doesn't support that device. This case
has yet to be seen in practice, but still, I'd like to fix it now. The
cleanest fix is to remove the trailing wildcard from i2c module aliases.
Here's a patch doing this.
Not all device type aliases need a trailing wildcard, in particular
the i2c aliases don't. Don't add a wildcard by default in do_table(),
instead let each device type handler add it if needed.
I have tested types acpi, dmi, eisa, i2c, ide, ieee1394, input, pci,
pcmcia, platform, pnp, scsi, serio, ssb and usb. Other types (ccw, of,
vio, parisc, sdio and virtio) are untested.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Acked-by: Jochen Friedrich <jochen@scram.de>
Signed-off-by: Sam Ravnborg <sam@ravnborg.org>
2008-05-02 20:37:21 +02:00
|
|
|
else
|
|
|
|
strcat(alias, "*");
|
2006-09-27 10:50:56 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-01-13 20:58:21 +01:00
|
|
|
/* Looks like: parisc:tNhvNrevNsvN */
|
|
|
|
static int do_parisc_entry(const char *filename, struct parisc_device_id *id,
|
|
|
|
char *alias)
|
|
|
|
{
|
|
|
|
id->hw_type = TO_NATIVE(id->hw_type);
|
|
|
|
id->hversion = TO_NATIVE(id->hversion);
|
|
|
|
id->hversion_rev = TO_NATIVE(id->hversion_rev);
|
|
|
|
id->sversion = TO_NATIVE(id->sversion);
|
|
|
|
|
|
|
|
strcpy(alias, "parisc:");
|
2007-01-13 21:02:09 +01:00
|
|
|
ADD(alias, "t", id->hw_type != PA_HWTYPE_ANY_ID, id->hw_type);
|
|
|
|
ADD(alias, "hv", id->hversion != PA_HVERSION_ANY_ID, id->hversion);
|
|
|
|
ADD(alias, "rev", id->hversion_rev != PA_HVERSION_REV_ANY_ID, id->hversion_rev);
|
|
|
|
ADD(alias, "sv", id->sversion != PA_SVERSION_ANY_ID, id->sversion);
|
2007-01-13 20:58:21 +01:00
|
|
|
|
modpost: i2c aliases need no trailing wildcard
Not all device types need a wildcard at the end of their module
aliases. In particular, for i2c module aliases, the trailing wildcard
is not only unneeded, it could also cause the wrong driver to be
loaded.
As I2C devices have no IDs, i2c module aliases are simple, arbitrary
device names. For example:
$ /sbin/modinfo lm90
filename: /lib/modules/2.6.25-git18/kernel/drivers/hwmon/lm90.ko
author: Jean Delvare <khali@linux-fr.org>
description: LM90/ADM1032 driver
license: GPL
vermagic: 2.6.25-git18 mod_unload
depends: hwmon
alias: i2c:lm90*
alias: i2c:adm1032*
alias: i2c:lm99*
alias: i2c:lm86*
alias: i2c:max6657*
alias: i2c:adt7461*
alias: i2c:max6680*
$
This would cause trouble if one I2C chip name matches the beginning of
another I2C chip name and both chips are supported by different
drivers. For example, an i2c device named lm9042 would cause the lm90
driver to be loaded, while it doesn't support that device. This case
has yet to be seen in practice, but still, I'd like to fix it now. The
cleanest fix is to remove the trailing wildcard from i2c module aliases.
Here's a patch doing this.
Not all device type aliases need a trailing wildcard, in particular
the i2c aliases don't. Don't add a wildcard by default in do_table(),
instead let each device type handler add it if needed.
I have tested types acpi, dmi, eisa, i2c, ide, ieee1394, input, pci,
pcmcia, platform, pnp, scsi, serio, ssb and usb. Other types (ccw, of,
vio, parisc, sdio and virtio) are untested.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Acked-by: Jochen Friedrich <jochen@scram.de>
Signed-off-by: Sam Ravnborg <sam@ravnborg.org>
2008-05-02 20:37:21 +02:00
|
|
|
add_wildcard(alias);
|
2007-01-13 20:58:21 +01:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-06-17 11:34:23 +02:00
|
|
|
/* Looks like: sdio:cNvNdN. */
|
|
|
|
static int do_sdio_entry(const char *filename,
|
|
|
|
struct sdio_device_id *id, char *alias)
|
|
|
|
{
|
|
|
|
id->class = TO_NATIVE(id->class);
|
|
|
|
id->vendor = TO_NATIVE(id->vendor);
|
|
|
|
id->device = TO_NATIVE(id->device);
|
|
|
|
|
|
|
|
strcpy(alias, "sdio:");
|
|
|
|
ADD(alias, "c", id->class != (__u8)SDIO_ANY_ID, id->class);
|
|
|
|
ADD(alias, "v", id->vendor != (__u16)SDIO_ANY_ID, id->vendor);
|
|
|
|
ADD(alias, "d", id->device != (__u16)SDIO_ANY_ID, id->device);
|
modpost: i2c aliases need no trailing wildcard
Not all device types need a wildcard at the end of their module
aliases. In particular, for i2c module aliases, the trailing wildcard
is not only unneeded, it could also cause the wrong driver to be
loaded.
As I2C devices have no IDs, i2c module aliases are simple, arbitrary
device names. For example:
$ /sbin/modinfo lm90
filename: /lib/modules/2.6.25-git18/kernel/drivers/hwmon/lm90.ko
author: Jean Delvare <khali@linux-fr.org>
description: LM90/ADM1032 driver
license: GPL
vermagic: 2.6.25-git18 mod_unload
depends: hwmon
alias: i2c:lm90*
alias: i2c:adm1032*
alias: i2c:lm99*
alias: i2c:lm86*
alias: i2c:max6657*
alias: i2c:adt7461*
alias: i2c:max6680*
$
This would cause trouble if one I2C chip name matches the beginning of
another I2C chip name and both chips are supported by different
drivers. For example, an i2c device named lm9042 would cause the lm90
driver to be loaded, while it doesn't support that device. This case
has yet to be seen in practice, but still, I'd like to fix it now. The
cleanest fix is to remove the trailing wildcard from i2c module aliases.
Here's a patch doing this.
Not all device type aliases need a trailing wildcard, in particular
the i2c aliases don't. Don't add a wildcard by default in do_table(),
instead let each device type handler add it if needed.
I have tested types acpi, dmi, eisa, i2c, ide, ieee1394, input, pci,
pcmcia, platform, pnp, scsi, serio, ssb and usb. Other types (ccw, of,
vio, parisc, sdio and virtio) are untested.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Acked-by: Jochen Friedrich <jochen@scram.de>
Signed-off-by: Sam Ravnborg <sam@ravnborg.org>
2008-05-02 20:37:21 +02:00
|
|
|
add_wildcard(alias);
|
2007-10-12 04:40:14 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-09-18 21:12:50 +02:00
|
|
|
/* Looks like: ssb:vNidNrevN. */
|
|
|
|
static int do_ssb_entry(const char *filename,
|
|
|
|
struct ssb_device_id *id, char *alias)
|
|
|
|
{
|
|
|
|
id->vendor = TO_NATIVE(id->vendor);
|
|
|
|
id->coreid = TO_NATIVE(id->coreid);
|
|
|
|
id->revision = TO_NATIVE(id->revision);
|
2007-06-17 11:34:23 +02:00
|
|
|
|
2007-09-18 21:12:50 +02:00
|
|
|
strcpy(alias, "ssb:");
|
|
|
|
ADD(alias, "v", id->vendor != SSB_ANY_VENDOR, id->vendor);
|
|
|
|
ADD(alias, "id", id->coreid != SSB_ANY_ID, id->coreid);
|
|
|
|
ADD(alias, "rev", id->revision != SSB_ANY_REV, id->revision);
|
modpost: i2c aliases need no trailing wildcard
Not all device types need a wildcard at the end of their module
aliases. In particular, for i2c module aliases, the trailing wildcard
is not only unneeded, it could also cause the wrong driver to be
loaded.
As I2C devices have no IDs, i2c module aliases are simple, arbitrary
device names. For example:
$ /sbin/modinfo lm90
filename: /lib/modules/2.6.25-git18/kernel/drivers/hwmon/lm90.ko
author: Jean Delvare <khali@linux-fr.org>
description: LM90/ADM1032 driver
license: GPL
vermagic: 2.6.25-git18 mod_unload
depends: hwmon
alias: i2c:lm90*
alias: i2c:adm1032*
alias: i2c:lm99*
alias: i2c:lm86*
alias: i2c:max6657*
alias: i2c:adt7461*
alias: i2c:max6680*
$
This would cause trouble if one I2C chip name matches the beginning of
another I2C chip name and both chips are supported by different
drivers. For example, an i2c device named lm9042 would cause the lm90
driver to be loaded, while it doesn't support that device. This case
has yet to be seen in practice, but still, I'd like to fix it now. The
cleanest fix is to remove the trailing wildcard from i2c module aliases.
Here's a patch doing this.
Not all device type aliases need a trailing wildcard, in particular
the i2c aliases don't. Don't add a wildcard by default in do_table(),
instead let each device type handler add it if needed.
I have tested types acpi, dmi, eisa, i2c, ide, ieee1394, input, pci,
pcmcia, platform, pnp, scsi, serio, ssb and usb. Other types (ccw, of,
vio, parisc, sdio and virtio) are untested.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Acked-by: Jochen Friedrich <jochen@scram.de>
Signed-off-by: Sam Ravnborg <sam@ravnborg.org>
2008-05-02 20:37:21 +02:00
|
|
|
add_wildcard(alias);
|
2007-06-17 11:34:23 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-10-22 03:03:39 +02:00
|
|
|
/* Looks like: virtio:dNvN */
|
|
|
|
static int do_virtio_entry(const char *filename, struct virtio_device_id *id,
|
|
|
|
char *alias)
|
|
|
|
{
|
|
|
|
id->device = TO_NATIVE(id->device);
|
|
|
|
id->vendor = TO_NATIVE(id->vendor);
|
|
|
|
|
|
|
|
strcpy(alias, "virtio:");
|
|
|
|
ADD(alias, "d", 1, id->device);
|
|
|
|
ADD(alias, "v", id->vendor != VIRTIO_DEV_ANY_ID, id->vendor);
|
|
|
|
|
modpost: i2c aliases need no trailing wildcard
Not all device types need a wildcard at the end of their module
aliases. In particular, for i2c module aliases, the trailing wildcard
is not only unneeded, it could also cause the wrong driver to be
loaded.
As I2C devices have no IDs, i2c module aliases are simple, arbitrary
device names. For example:
$ /sbin/modinfo lm90
filename: /lib/modules/2.6.25-git18/kernel/drivers/hwmon/lm90.ko
author: Jean Delvare <khali@linux-fr.org>
description: LM90/ADM1032 driver
license: GPL
vermagic: 2.6.25-git18 mod_unload
depends: hwmon
alias: i2c:lm90*
alias: i2c:adm1032*
alias: i2c:lm99*
alias: i2c:lm86*
alias: i2c:max6657*
alias: i2c:adt7461*
alias: i2c:max6680*
$
This would cause trouble if one I2C chip name matches the beginning of
another I2C chip name and both chips are supported by different
drivers. For example, an i2c device named lm9042 would cause the lm90
driver to be loaded, while it doesn't support that device. This case
has yet to be seen in practice, but still, I'd like to fix it now. The
cleanest fix is to remove the trailing wildcard from i2c module aliases.
Here's a patch doing this.
Not all device type aliases need a trailing wildcard, in particular
the i2c aliases don't. Don't add a wildcard by default in do_table(),
instead let each device type handler add it if needed.
I have tested types acpi, dmi, eisa, i2c, ide, ieee1394, input, pci,
pcmcia, platform, pnp, scsi, serio, ssb and usb. Other types (ccw, of,
vio, parisc, sdio and virtio) are untested.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Acked-by: Jochen Friedrich <jochen@scram.de>
Signed-off-by: Sam Ravnborg <sam@ravnborg.org>
2008-05-02 20:37:21 +02:00
|
|
|
add_wildcard(alias);
|
2007-10-22 03:03:39 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-04-29 23:11:39 +02:00
|
|
|
/* Looks like: i2c:S */
|
|
|
|
static int do_i2c_entry(const char *filename, struct i2c_device_id *id,
|
|
|
|
char *alias)
|
|
|
|
{
|
|
|
|
sprintf(alias, I2C_MODULE_PREFIX "%s", id->name);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Ignore any prefix, eg. v850 prepends _ */
|
|
|
|
static inline int sym_is(const char *symbol, const char *name)
|
|
|
|
{
|
|
|
|
const char *match;
|
|
|
|
|
|
|
|
match = strstr(symbol, name);
|
|
|
|
if (!match)
|
|
|
|
return 0;
|
|
|
|
return match[strlen(symbol)] == '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
static void do_table(void *symval, unsigned long size,
|
|
|
|
unsigned long id_size,
|
2006-07-09 16:26:07 +02:00
|
|
|
const char *device_id,
|
2005-04-17 00:20:36 +02:00
|
|
|
void *function,
|
|
|
|
struct module *mod)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
char alias[500];
|
|
|
|
int (*do_entry)(const char *, void *entry, char *alias) = function;
|
|
|
|
|
2007-09-16 11:15:46 +02:00
|
|
|
device_id_check(mod->name, device_id, size, id_size, symval);
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Leave last one: it's the terminator. */
|
|
|
|
size -= id_size;
|
|
|
|
|
|
|
|
for (i = 0; i < size; i += id_size) {
|
|
|
|
if (do_entry(mod->name, symval+i, alias)) {
|
|
|
|
buf_printf(&mod->dev_table_buf,
|
|
|
|
"MODULE_ALIAS(\"%s\");\n", alias);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create MODULE_ALIAS() statements.
|
|
|
|
* At this time, we cannot write the actual output C source yet,
|
|
|
|
* so we write into the mod->dev_table_buf buffer. */
|
|
|
|
void handle_moddevtable(struct module *mod, struct elf_info *info,
|
|
|
|
Elf_Sym *sym, const char *symname)
|
|
|
|
{
|
|
|
|
void *symval;
|
2007-09-16 11:15:46 +02:00
|
|
|
char *zeros = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* We're looking for a section relative symbol */
|
|
|
|
if (!sym->st_shndx || sym->st_shndx >= info->hdr->e_shnum)
|
|
|
|
return;
|
|
|
|
|
2007-09-16 11:15:46 +02:00
|
|
|
/* Handle all-NULL symbols allocated into .bss */
|
|
|
|
if (info->sechdrs[sym->st_shndx].sh_type & SHT_NOBITS) {
|
|
|
|
zeros = calloc(1, sym->st_size);
|
|
|
|
symval = zeros;
|
|
|
|
} else {
|
|
|
|
symval = (void *)info->hdr
|
|
|
|
+ info->sechdrs[sym->st_shndx].sh_offset
|
|
|
|
+ sym->st_value;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (sym_is(symname, "__mod_pci_device_table"))
|
2006-07-09 16:26:07 +02:00
|
|
|
do_table(symval, sym->st_size,
|
|
|
|
sizeof(struct pci_device_id), "pci",
|
2005-04-17 00:20:36 +02:00
|
|
|
do_pci_entry, mod);
|
|
|
|
else if (sym_is(symname, "__mod_usb_device_table"))
|
2005-04-23 00:07:01 +02:00
|
|
|
/* special case to handle bcdDevice ranges */
|
|
|
|
do_usb_table(symval, sym->st_size, mod);
|
2005-04-17 00:20:36 +02:00
|
|
|
else if (sym_is(symname, "__mod_ieee1394_device_table"))
|
2006-07-09 16:26:07 +02:00
|
|
|
do_table(symval, sym->st_size,
|
|
|
|
sizeof(struct ieee1394_device_id), "ieee1394",
|
2005-04-17 00:20:36 +02:00
|
|
|
do_ieee1394_entry, mod);
|
|
|
|
else if (sym_is(symname, "__mod_ccw_device_table"))
|
2006-07-09 16:26:07 +02:00
|
|
|
do_table(symval, sym->st_size,
|
|
|
|
sizeof(struct ccw_device_id), "ccw",
|
2005-04-17 00:20:36 +02:00
|
|
|
do_ccw_entry, mod);
|
2006-09-20 15:58:25 +02:00
|
|
|
else if (sym_is(symname, "__mod_ap_device_table"))
|
|
|
|
do_table(symval, sym->st_size,
|
|
|
|
sizeof(struct ap_device_id), "ap",
|
|
|
|
do_ap_entry, mod);
|
2008-07-14 09:58:44 +02:00
|
|
|
else if (sym_is(symname, "__mod_css_device_table"))
|
|
|
|
do_table(symval, sym->st_size,
|
|
|
|
sizeof(struct css_device_id), "css",
|
|
|
|
do_css_entry, mod);
|
2005-04-17 00:20:36 +02:00
|
|
|
else if (sym_is(symname, "__mod_serio_device_table"))
|
2006-07-09 16:26:07 +02:00
|
|
|
do_table(symval, sym->st_size,
|
|
|
|
sizeof(struct serio_device_id), "serio",
|
2005-04-17 00:20:36 +02:00
|
|
|
do_serio_entry, mod);
|
2007-07-23 14:43:51 +02:00
|
|
|
else if (sym_is(symname, "__mod_acpi_device_table"))
|
|
|
|
do_table(symval, sym->st_size,
|
|
|
|
sizeof(struct acpi_device_id), "acpi",
|
|
|
|
do_acpi_entry, mod);
|
2005-04-17 00:20:36 +02:00
|
|
|
else if (sym_is(symname, "__mod_pnp_device_table"))
|
2006-07-09 16:26:07 +02:00
|
|
|
do_table(symval, sym->st_size,
|
|
|
|
sizeof(struct pnp_device_id), "pnp",
|
2005-04-17 00:20:36 +02:00
|
|
|
do_pnp_entry, mod);
|
|
|
|
else if (sym_is(symname, "__mod_pnp_card_device_table"))
|
2008-02-21 00:35:54 +01:00
|
|
|
do_pnp_card_entries(symval, sym->st_size, mod);
|
2005-06-28 01:28:12 +02:00
|
|
|
else if (sym_is(symname, "__mod_pcmcia_device_table"))
|
2006-07-09 16:26:07 +02:00
|
|
|
do_table(symval, sym->st_size,
|
|
|
|
sizeof(struct pcmcia_device_id), "pcmcia",
|
2005-06-28 01:28:12 +02:00
|
|
|
do_pcmcia_entry, mod);
|
2005-07-06 21:44:41 +02:00
|
|
|
else if (sym_is(symname, "__mod_of_device_table"))
|
2006-07-09 16:26:07 +02:00
|
|
|
do_table(symval, sym->st_size,
|
|
|
|
sizeof(struct of_device_id), "of",
|
2005-07-06 21:44:41 +02:00
|
|
|
do_of_entry, mod);
|
2005-08-17 08:42:59 +02:00
|
|
|
else if (sym_is(symname, "__mod_vio_device_table"))
|
2006-07-09 16:26:07 +02:00
|
|
|
do_table(symval, sym->st_size,
|
|
|
|
sizeof(struct vio_device_id), "vio",
|
2005-08-17 08:42:59 +02:00
|
|
|
do_vio_entry, mod);
|
2005-12-07 21:40:34 +01:00
|
|
|
else if (sym_is(symname, "__mod_input_device_table"))
|
2006-07-09 16:26:07 +02:00
|
|
|
do_table(symval, sym->st_size,
|
|
|
|
sizeof(struct input_device_id), "input",
|
2005-12-07 21:40:34 +01:00
|
|
|
do_input_entry, mod);
|
2006-09-27 10:50:56 +02:00
|
|
|
else if (sym_is(symname, "__mod_eisa_device_table"))
|
|
|
|
do_table(symval, sym->st_size,
|
|
|
|
sizeof(struct eisa_device_id), "eisa",
|
|
|
|
do_eisa_entry, mod);
|
2007-01-13 20:58:21 +01:00
|
|
|
else if (sym_is(symname, "__mod_parisc_device_table"))
|
|
|
|
do_table(symval, sym->st_size,
|
|
|
|
sizeof(struct parisc_device_id), "parisc",
|
|
|
|
do_parisc_entry, mod);
|
2007-06-17 11:34:23 +02:00
|
|
|
else if (sym_is(symname, "__mod_sdio_device_table"))
|
|
|
|
do_table(symval, sym->st_size,
|
|
|
|
sizeof(struct sdio_device_id), "sdio",
|
|
|
|
do_sdio_entry, mod);
|
2007-09-18 21:12:50 +02:00
|
|
|
else if (sym_is(symname, "__mod_ssb_device_table"))
|
|
|
|
do_table(symval, sym->st_size,
|
|
|
|
sizeof(struct ssb_device_id), "ssb",
|
|
|
|
do_ssb_entry, mod);
|
2007-10-22 03:03:39 +02:00
|
|
|
else if (sym_is(symname, "__mod_virtio_device_table"))
|
|
|
|
do_table(symval, sym->st_size,
|
|
|
|
sizeof(struct virtio_device_id), "virtio",
|
|
|
|
do_virtio_entry, mod);
|
2008-04-29 23:11:39 +02:00
|
|
|
else if (sym_is(symname, "__mod_i2c_device_table"))
|
|
|
|
do_table(symval, sym->st_size,
|
|
|
|
sizeof(struct i2c_device_id), "i2c",
|
|
|
|
do_i2c_entry, mod);
|
2007-09-16 11:15:46 +02:00
|
|
|
free(zeros);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Now add out buffered information to the generated C source */
|
|
|
|
void add_moddevtable(struct buffer *buf, struct module *mod)
|
|
|
|
{
|
|
|
|
buf_printf(buf, "\n");
|
|
|
|
buf_write(buf, mod->dev_table_buf.p, mod->dev_table_buf.pos);
|
|
|
|
free(mod->dev_table_buf.p);
|
|
|
|
}
|