2005-04-17 06:20:36 +08: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"
|
2013-01-21 00:58:47 +08:00
|
|
|
#include "devicetable-offsets.h"
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* 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-08 04:40:34 +08:00
|
|
|
#define BITS_PER_LONG 32
|
2005-04-17 06:20:36 +08:00
|
|
|
#else
|
|
|
|
typedef Elf64_Addr kernel_ulong_t;
|
2005-12-08 04:40:34 +08:00
|
|
|
#define BITS_PER_LONG 64
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
|
|
|
#ifdef __sun__
|
|
|
|
#include <inttypes.h>
|
|
|
|
#else
|
|
|
|
#include <stdint.h>
|
|
|
|
#endif
|
|
|
|
|
2005-07-07 03:44:41 +08:00
|
|
|
#include <ctype.h>
|
2012-01-13 07:02:15 +08:00
|
|
|
#include <stdbool.h>
|
2005-07-07 03:44:41 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
typedef uint32_t __u32;
|
|
|
|
typedef uint16_t __u16;
|
|
|
|
typedef unsigned char __u8;
|
2015-05-28 08:17:27 +08:00
|
|
|
typedef struct {
|
|
|
|
__u8 b[16];
|
|
|
|
} uuid_le;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Big exception to the "don't include kernel headers into userspace, which
|
2006-03-03 23:46:04 +08:00
|
|
|
* even potentially has different endianness and word sizes, since
|
2005-04-17 06:20:36 +08:00
|
|
|
* we handle those differences explicitly below */
|
|
|
|
#include "../../include/linux/mod_devicetable.h"
|
|
|
|
|
2012-01-13 07:02:16 +08:00
|
|
|
/* This array collects all instances that use the generic do_table */
|
|
|
|
struct devtable {
|
2014-02-03 08:44:13 +08:00
|
|
|
const char *device_id; /* name of table, __mod_<name>__*_device_table. */
|
2012-01-13 07:02:16 +08:00
|
|
|
unsigned long id_size;
|
|
|
|
void *function;
|
|
|
|
};
|
|
|
|
|
2012-02-24 15:23:53 +08:00
|
|
|
#define ___cat(a,b) a ## b
|
|
|
|
#define __cat(a,b) ___cat(a,b)
|
|
|
|
|
|
|
|
/* we need some special handling for this host tool running eventually on
|
|
|
|
* Darwin. The Mach-O section handling is a bit different than ELF section
|
|
|
|
* handling. The differnces in detail are:
|
|
|
|
* a) we have segments which have sections
|
|
|
|
* b) we need a API call to get the respective section symbols */
|
|
|
|
#if defined(__MACH__)
|
|
|
|
#include <mach-o/getsect.h>
|
|
|
|
|
|
|
|
#define INIT_SECTION(name) do { \
|
|
|
|
unsigned long name ## _len; \
|
|
|
|
char *__cat(pstart_,name) = getsectdata("__TEXT", \
|
|
|
|
#name, &__cat(name,_len)); \
|
|
|
|
char *__cat(pstop_,name) = __cat(pstart_,name) + \
|
|
|
|
__cat(name, _len); \
|
|
|
|
__cat(__start_,name) = (void *)__cat(pstart_,name); \
|
|
|
|
__cat(__stop_,name) = (void *)__cat(pstop_,name); \
|
|
|
|
} while (0)
|
|
|
|
#define SECTION(name) __attribute__((section("__TEXT, " #name)))
|
|
|
|
|
|
|
|
struct devtable **__start___devtable, **__stop___devtable;
|
|
|
|
#else
|
|
|
|
#define INIT_SECTION(name) /* no-op for ELF */
|
|
|
|
#define SECTION(name) __attribute__((section(#name)))
|
|
|
|
|
2012-01-13 07:02:16 +08:00
|
|
|
/* We construct a table of pointers in an ELF section (pointers generally
|
|
|
|
* go unpadded by gcc). ld creates boundary syms for us. */
|
|
|
|
extern struct devtable *__start___devtable[], *__stop___devtable[];
|
2012-02-24 15:23:53 +08:00
|
|
|
#endif /* __MACH__ */
|
2012-01-13 07:02:16 +08:00
|
|
|
|
2013-06-09 10:33:55 +08:00
|
|
|
#if !defined(__used)
|
|
|
|
# if __GNUC__ == 3 && __GNUC_MINOR__ < 3
|
|
|
|
# define __used __attribute__((__unused__))
|
|
|
|
# else
|
|
|
|
# define __used __attribute__((__used__))
|
|
|
|
# endif
|
2012-01-13 07:02:16 +08:00
|
|
|
#endif
|
|
|
|
|
2013-01-21 00:58:47 +08:00
|
|
|
/* Define a variable f that holds the value of field f of struct devid
|
|
|
|
* based at address m.
|
|
|
|
*/
|
|
|
|
#define DEF_FIELD(m, devid, f) \
|
|
|
|
typeof(((struct devid *)0)->f) f = TO_NATIVE(*(typeof(f) *)((m) + OFF_##devid##_##f))
|
|
|
|
/* Define a variable f that holds the address of field f of struct devid
|
|
|
|
* based at address m. Due to the way typeof works, for a field of type
|
|
|
|
* T[N] the variable has type T(*)[N], _not_ T*.
|
|
|
|
*/
|
|
|
|
#define DEF_FIELD_ADDR(m, devid, f) \
|
|
|
|
typeof(((struct devid *)0)->f) *f = ((m) + OFF_##devid##_##f)
|
|
|
|
|
2012-01-13 07:02:16 +08:00
|
|
|
/* Add a table entry. We test function type matches while we're here. */
|
|
|
|
#define ADD_TO_DEVTABLE(device_id, type, function) \
|
|
|
|
static struct devtable __cat(devtable,__LINE__) = { \
|
|
|
|
device_id + 0*sizeof((function)((const char *)NULL, \
|
2013-01-21 00:58:47 +08:00
|
|
|
(void *)NULL, \
|
2012-01-13 07:02:16 +08:00
|
|
|
(char *)NULL)), \
|
2013-01-21 00:58:47 +08:00
|
|
|
SIZE_##type, (function) }; \
|
2012-02-24 15:23:53 +08:00
|
|
|
static struct devtable *SECTION(__devtable) __used \
|
|
|
|
__cat(devtable_ptr,__LINE__) = &__cat(devtable,__LINE__)
|
2012-01-13 07:02:16 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#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)
|
|
|
|
|
2016-01-15 07:17:02 +08:00
|
|
|
/* End in a wildcard, for future extension */
|
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-03 02:37:21 +08:00
|
|
|
static inline void add_wildcard(char *str)
|
|
|
|
{
|
|
|
|
int len = strlen(str);
|
|
|
|
|
|
|
|
if (str[len - 1] != '*')
|
|
|
|
strcat(str + len, "*");
|
|
|
|
}
|
|
|
|
|
2015-05-28 08:17:27 +08:00
|
|
|
static inline void add_uuid(char *str, uuid_le uuid)
|
2015-05-07 20:54:02 +08:00
|
|
|
{
|
|
|
|
int len = strlen(str);
|
|
|
|
|
2015-09-10 15:17:59 +08:00
|
|
|
sprintf(str + len, "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
|
|
|
|
uuid.b[3], uuid.b[2], uuid.b[1], uuid.b[0],
|
|
|
|
uuid.b[5], uuid.b[4], uuid.b[7], uuid.b[6],
|
|
|
|
uuid.b[8], uuid.b[9], uuid.b[10], uuid.b[11],
|
|
|
|
uuid.b[12], uuid.b[13], uuid.b[14], uuid.b[15]);
|
2015-05-07 20:54:02 +08:00
|
|
|
}
|
|
|
|
|
2006-07-09 22:26:07 +08: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 17:15:46 +08:00
|
|
|
* Also verify that the final entry in the table is all zeros.
|
2008-03-24 04:38:54 +08:00
|
|
|
* Ignore both checks if build host differ from target host and size differs.
|
2006-07-09 22:26:07 +08:00
|
|
|
**/
|
2007-09-16 17:15:46 +08: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 22:26:07 +08:00
|
|
|
{
|
2007-09-16 17:15:46 +08:00
|
|
|
int i;
|
|
|
|
|
2006-07-09 22:26:07 +08:00
|
|
|
if (size % id_size || size < id_size) {
|
|
|
|
fatal("%s: sizeof(struct %s_device_id)=%lu is not a modulo "
|
2014-02-03 08:44:13 +08:00
|
|
|
"of the size of "
|
|
|
|
"section __mod_%s__<identifier>_device_table=%lu.\n"
|
2006-07-09 22:26:07 +08:00
|
|
|
"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 17:15:46 +08: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 22:26:07 +08:00
|
|
|
}
|
|
|
|
|
2005-04-23 06:07:01 +08:00
|
|
|
/* USB is special because the bcdDevice can be matched against a numeric range */
|
2012-05-19 03:27:43 +08:00
|
|
|
/* Looks like "usb:vNpNdNdcNdscNdpNicNiscNipNinN" */
|
2013-01-21 00:58:47 +08:00
|
|
|
static void do_usb_entry(void *symval,
|
2005-04-23 06:07:01 +08:00
|
|
|
unsigned int bcdDevice_initial, int bcdDevice_initial_digits,
|
|
|
|
unsigned char range_lo, unsigned char range_hi,
|
2009-11-19 09:11:23 +08:00
|
|
|
unsigned char max, struct module *mod)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-04-23 06:07:01 +08:00
|
|
|
char alias[500];
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD(symval, usb_device_id, match_flags);
|
|
|
|
DEF_FIELD(symval, usb_device_id, idVendor);
|
|
|
|
DEF_FIELD(symval, usb_device_id, idProduct);
|
|
|
|
DEF_FIELD(symval, usb_device_id, bcdDevice_lo);
|
|
|
|
DEF_FIELD(symval, usb_device_id, bDeviceClass);
|
|
|
|
DEF_FIELD(symval, usb_device_id, bDeviceSubClass);
|
|
|
|
DEF_FIELD(symval, usb_device_id, bDeviceProtocol);
|
|
|
|
DEF_FIELD(symval, usb_device_id, bInterfaceClass);
|
|
|
|
DEF_FIELD(symval, usb_device_id, bInterfaceSubClass);
|
|
|
|
DEF_FIELD(symval, usb_device_id, bInterfaceProtocol);
|
|
|
|
DEF_FIELD(symval, usb_device_id, bInterfaceNumber);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
strcpy(alias, "usb:");
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD(alias, "v", match_flags&USB_DEVICE_ID_MATCH_VENDOR,
|
|
|
|
idVendor);
|
|
|
|
ADD(alias, "p", match_flags&USB_DEVICE_ID_MATCH_PRODUCT,
|
|
|
|
idProduct);
|
2005-04-23 06:07:01 +08:00
|
|
|
|
|
|
|
strcat(alias, "d");
|
|
|
|
if (bcdDevice_initial_digits)
|
|
|
|
sprintf(alias + strlen(alias), "%0*X",
|
|
|
|
bcdDevice_initial_digits, bcdDevice_initial);
|
|
|
|
if (range_lo == range_hi)
|
2009-11-19 09:11:23 +08:00
|
|
|
sprintf(alias + strlen(alias), "%X", range_lo);
|
|
|
|
else if (range_lo > 0 || range_hi < max) {
|
|
|
|
if (range_lo > 0x9 || range_hi < 0xA)
|
|
|
|
sprintf(alias + strlen(alias),
|
|
|
|
"[%X-%X]",
|
|
|
|
range_lo,
|
|
|
|
range_hi);
|
|
|
|
else {
|
|
|
|
sprintf(alias + strlen(alias),
|
|
|
|
range_lo < 0x9 ? "[%X-9" : "[%X",
|
|
|
|
range_lo);
|
|
|
|
sprintf(alias + strlen(alias),
|
2014-02-08 02:15:11 +08:00
|
|
|
range_hi > 0xA ? "A-%X]" : "%X]",
|
|
|
|
range_hi);
|
2009-11-19 09:11:23 +08:00
|
|
|
}
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
if (bcdDevice_initial_digits < (sizeof(bcdDevice_lo) * 2 - 1))
|
2005-04-23 06:07:01 +08:00
|
|
|
strcat(alias, "*");
|
|
|
|
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD(alias, "dc", match_flags&USB_DEVICE_ID_MATCH_DEV_CLASS,
|
|
|
|
bDeviceClass);
|
|
|
|
ADD(alias, "dsc", match_flags&USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
|
|
|
|
bDeviceSubClass);
|
|
|
|
ADD(alias, "dp", match_flags&USB_DEVICE_ID_MATCH_DEV_PROTOCOL,
|
|
|
|
bDeviceProtocol);
|
|
|
|
ADD(alias, "ic", match_flags&USB_DEVICE_ID_MATCH_INT_CLASS,
|
|
|
|
bInterfaceClass);
|
|
|
|
ADD(alias, "isc", match_flags&USB_DEVICE_ID_MATCH_INT_SUBCLASS,
|
|
|
|
bInterfaceSubClass);
|
|
|
|
ADD(alias, "ip", match_flags&USB_DEVICE_ID_MATCH_INT_PROTOCOL,
|
|
|
|
bInterfaceProtocol);
|
|
|
|
ADD(alias, "in", match_flags&USB_DEVICE_ID_MATCH_INT_NUMBER,
|
|
|
|
bInterfaceNumber);
|
2005-04-23 06:07:01 +08: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-03 02:37:21 +08:00
|
|
|
add_wildcard(alias);
|
2005-04-23 06:07:01 +08:00
|
|
|
buf_printf(&mod->dev_table_buf,
|
|
|
|
"MODULE_ALIAS(\"%s\");\n", alias);
|
|
|
|
}
|
|
|
|
|
2009-11-19 09:15:28 +08:00
|
|
|
/* Handles increment/decrement of BCD formatted integers */
|
|
|
|
/* Returns the previous value, so it works like i++ or i-- */
|
|
|
|
static unsigned int incbcd(unsigned int *bcd,
|
|
|
|
int inc,
|
|
|
|
unsigned char max,
|
|
|
|
size_t chars)
|
|
|
|
{
|
|
|
|
unsigned int init = *bcd, i, j;
|
|
|
|
unsigned long long c, dec = 0;
|
|
|
|
|
|
|
|
/* If bcd is not in BCD format, just increment */
|
|
|
|
if (max > 0x9) {
|
|
|
|
*bcd += inc;
|
|
|
|
return init;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Convert BCD to Decimal */
|
|
|
|
for (i=0 ; i < chars ; i++) {
|
|
|
|
c = (*bcd >> (i << 2)) & 0xf;
|
|
|
|
c = c > 9 ? 9 : c; /* force to bcd just in case */
|
|
|
|
for (j=0 ; j < i ; j++)
|
|
|
|
c = c * 10;
|
|
|
|
dec += c;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Do our increment/decrement */
|
|
|
|
dec += inc;
|
|
|
|
*bcd = 0;
|
|
|
|
|
|
|
|
/* Convert back to BCD */
|
|
|
|
for (i=0 ; i < chars ; i++) {
|
|
|
|
for (c=1,j=0 ; j < i ; j++)
|
|
|
|
c = c * 10;
|
|
|
|
c = (dec / c) % 10;
|
|
|
|
*bcd += c << (i << 2);
|
|
|
|
}
|
|
|
|
return init;
|
|
|
|
}
|
|
|
|
|
2013-01-21 00:58:47 +08:00
|
|
|
static void do_usb_entry_multi(void *symval, struct module *mod)
|
2005-04-23 06:07:01 +08:00
|
|
|
{
|
|
|
|
unsigned int devlo, devhi;
|
2009-11-19 09:11:23 +08:00
|
|
|
unsigned char chi, clo, max;
|
2005-04-23 06:07:01 +08:00
|
|
|
int ndigits;
|
|
|
|
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD(symval, usb_device_id, match_flags);
|
|
|
|
DEF_FIELD(symval, usb_device_id, idVendor);
|
|
|
|
DEF_FIELD(symval, usb_device_id, idProduct);
|
|
|
|
DEF_FIELD(symval, usb_device_id, bcdDevice_lo);
|
|
|
|
DEF_FIELD(symval, usb_device_id, bcdDevice_hi);
|
|
|
|
DEF_FIELD(symval, usb_device_id, bDeviceClass);
|
|
|
|
DEF_FIELD(symval, usb_device_id, bInterfaceClass);
|
2005-04-23 06:07:01 +08:00
|
|
|
|
2013-01-21 00:58:47 +08:00
|
|
|
devlo = match_flags & USB_DEVICE_ID_MATCH_DEV_LO ?
|
|
|
|
bcdDevice_lo : 0x0U;
|
|
|
|
devhi = match_flags & USB_DEVICE_ID_MATCH_DEV_HI ?
|
|
|
|
bcdDevice_hi : ~0x0U;
|
2005-04-23 06:07:01 +08:00
|
|
|
|
2009-11-19 09:11:23 +08:00
|
|
|
/* Figure out if this entry is in bcd or hex format */
|
|
|
|
max = 0x9; /* Default to decimal format */
|
2013-01-21 00:58:47 +08:00
|
|
|
for (ndigits = 0 ; ndigits < sizeof(bcdDevice_lo) * 2 ; ndigits++) {
|
2009-11-19 09:11:23 +08:00
|
|
|
clo = (devlo >> (ndigits << 2)) & 0xf;
|
|
|
|
chi = ((devhi > 0x9999 ? 0x9999 : devhi) >> (ndigits << 2)) & 0xf;
|
|
|
|
if (clo > max || chi > max) {
|
|
|
|
max = 0xf;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-23 06:07:01 +08:00
|
|
|
/*
|
|
|
|
* Some modules (visor) have empty slots as placeholder for
|
|
|
|
* run-time specification that results in catch-all alias
|
|
|
|
*/
|
2013-01-21 00:58:47 +08:00
|
|
|
if (!(idVendor | idProduct | bDeviceClass | bInterfaceClass))
|
2005-04-23 06:07:01 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
/* Convert numeric bcdDevice range into fnmatch-able pattern(s) */
|
2013-01-21 00:58:47 +08:00
|
|
|
for (ndigits = sizeof(bcdDevice_lo) * 2 - 1; devlo <= devhi; ndigits--) {
|
2005-04-23 06:07:01 +08:00
|
|
|
clo = devlo & 0xf;
|
|
|
|
chi = devhi & 0xf;
|
2009-11-19 09:11:23 +08:00
|
|
|
if (chi > max) /* If we are in bcd mode, truncate if necessary */
|
|
|
|
chi = max;
|
2005-04-23 06:07:01 +08:00
|
|
|
devlo >>= 4;
|
|
|
|
devhi >>= 4;
|
|
|
|
|
|
|
|
if (devlo == devhi || !ndigits) {
|
2013-01-21 00:58:47 +08:00
|
|
|
do_usb_entry(symval, devlo, ndigits, clo, chi, max, mod);
|
2005-04-23 06:07:01 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-11-19 09:11:23 +08:00
|
|
|
if (clo > 0x0)
|
2013-01-21 00:58:47 +08:00
|
|
|
do_usb_entry(symval,
|
2009-11-19 09:15:28 +08:00
|
|
|
incbcd(&devlo, 1, max,
|
2013-01-21 00:58:47 +08:00
|
|
|
sizeof(bcdDevice_lo) * 2),
|
2009-11-19 09:15:28 +08:00
|
|
|
ndigits, clo, max, max, mod);
|
2005-04-23 06:07:01 +08:00
|
|
|
|
2009-11-19 09:11:23 +08:00
|
|
|
if (chi < max)
|
2013-01-21 00:58:47 +08:00
|
|
|
do_usb_entry(symval,
|
2009-11-19 09:15:28 +08:00
|
|
|
incbcd(&devhi, -1, max,
|
2013-01-21 00:58:47 +08:00
|
|
|
sizeof(bcdDevice_lo) * 2),
|
2009-11-19 09:15:28 +08:00
|
|
|
ndigits, 0x0, chi, max, mod);
|
2005-04-23 06:07:01 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void do_usb_table(void *symval, unsigned long size,
|
|
|
|
struct module *mod)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
2013-01-21 00:58:47 +08:00
|
|
|
const unsigned long id_size = SIZE_usb_device_id;
|
2005-04-23 06:07:01 +08:00
|
|
|
|
2007-09-16 17:15:46 +08:00
|
|
|
device_id_check(mod->name, "usb", size, id_size, symval);
|
2006-07-09 22:26:07 +08:00
|
|
|
|
2005-04-23 06:07:01 +08: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 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
modpost: fix module autoloading for OF devices with generic compatible property
Since the wildcard at the end of OF module aliases is gone, autoloading
of modules that don't match a device's last (most generic) compatible
value fails.
For example the CODA960 VPU on i.MX6Q has the SoC specific compatible
"fsl,imx6q-vpu" and the generic compatible "cnm,coda960". Since the
driver currently only works with knowledge about the SoC specific
integration, it doesn't list "cnm,cod960" in the module device table.
This results in the device compatible
"of:NvpuT<NULL>Cfsl,imx6q-vpuCcnm,coda960" not matching the module alias
"of:N*T*Cfsl,imx6q-vpu" anymore, whereas before commit 2f632369ab79
("modpost: don't add a trailing wildcard for OF module aliases") it
matched the module alias "of:N*T*Cfsl,imx6q-vpu*".
This patch adds two module aliases for each compatible, one without the
wildcard and one with "C*" appended.
$ modinfo coda | grep imx6q
alias: of:N*T*Cfsl,imx6q-vpuC*
alias: of:N*T*Cfsl,imx6q-vpu
Fixes: 2f632369ab79 ("modpost: don't add a trailing wildcard for OF module aliases")
Link: http://lkml.kernel.org/r/1462203339-15340-1-git-send-email-p.zabel@pengutronix.de
Signed-off-by: Philipp Zabel <p.zabel@pengutronix.de>
Cc: Javier Martinez Canillas <javier@osg.samsung.com>
Cc: Brian Norris <computersforpeace@gmail.com>
Cc: Sjoerd Simons <sjoerd.simons@collabora.co.uk>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: <stable@vger.kernel.org> [4.5+]
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-05-06 07:22:29 +08:00
|
|
|
static void do_of_entry_multi(void *symval, struct module *mod)
|
|
|
|
{
|
|
|
|
char alias[500];
|
|
|
|
int len;
|
|
|
|
char *tmp;
|
|
|
|
|
|
|
|
DEF_FIELD_ADDR(symval, of_device_id, name);
|
|
|
|
DEF_FIELD_ADDR(symval, of_device_id, type);
|
|
|
|
DEF_FIELD_ADDR(symval, of_device_id, compatible);
|
|
|
|
|
|
|
|
len = sprintf(alias, "of:N%sT%s", (*name)[0] ? *name : "*",
|
|
|
|
(*type)[0] ? *type : "*");
|
|
|
|
|
2016-06-07 00:48:38 +08:00
|
|
|
if ((*compatible)[0])
|
modpost: fix module autoloading for OF devices with generic compatible property
Since the wildcard at the end of OF module aliases is gone, autoloading
of modules that don't match a device's last (most generic) compatible
value fails.
For example the CODA960 VPU on i.MX6Q has the SoC specific compatible
"fsl,imx6q-vpu" and the generic compatible "cnm,coda960". Since the
driver currently only works with knowledge about the SoC specific
integration, it doesn't list "cnm,cod960" in the module device table.
This results in the device compatible
"of:NvpuT<NULL>Cfsl,imx6q-vpuCcnm,coda960" not matching the module alias
"of:N*T*Cfsl,imx6q-vpu" anymore, whereas before commit 2f632369ab79
("modpost: don't add a trailing wildcard for OF module aliases") it
matched the module alias "of:N*T*Cfsl,imx6q-vpu*".
This patch adds two module aliases for each compatible, one without the
wildcard and one with "C*" appended.
$ modinfo coda | grep imx6q
alias: of:N*T*Cfsl,imx6q-vpuC*
alias: of:N*T*Cfsl,imx6q-vpu
Fixes: 2f632369ab79 ("modpost: don't add a trailing wildcard for OF module aliases")
Link: http://lkml.kernel.org/r/1462203339-15340-1-git-send-email-p.zabel@pengutronix.de
Signed-off-by: Philipp Zabel <p.zabel@pengutronix.de>
Cc: Javier Martinez Canillas <javier@osg.samsung.com>
Cc: Brian Norris <computersforpeace@gmail.com>
Cc: Sjoerd Simons <sjoerd.simons@collabora.co.uk>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: <stable@vger.kernel.org> [4.5+]
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-05-06 07:22:29 +08:00
|
|
|
sprintf(&alias[len], "%sC%s", (*type)[0] ? "*" : "",
|
|
|
|
*compatible);
|
|
|
|
|
|
|
|
/* Replace all whitespace with underscores */
|
|
|
|
for (tmp = alias; tmp && *tmp; tmp++)
|
|
|
|
if (isspace(*tmp))
|
|
|
|
*tmp = '_';
|
|
|
|
|
|
|
|
buf_printf(&mod->dev_table_buf, "MODULE_ALIAS(\"%s\");\n", alias);
|
|
|
|
strcat(alias, "C");
|
|
|
|
add_wildcard(alias);
|
|
|
|
buf_printf(&mod->dev_table_buf, "MODULE_ALIAS(\"%s\");\n", alias);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void do_of_table(void *symval, unsigned long size,
|
|
|
|
struct module *mod)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
const unsigned long id_size = SIZE_of_device_id;
|
|
|
|
|
|
|
|
device_id_check(mod->name, "of", size, id_size, symval);
|
|
|
|
|
|
|
|
/* Leave last one: it's the terminator. */
|
|
|
|
size -= id_size;
|
|
|
|
|
|
|
|
for (i = 0; i < size; i += id_size)
|
|
|
|
do_of_entry_multi(symval + i, mod);
|
|
|
|
}
|
|
|
|
|
2008-05-19 21:50:01 +08:00
|
|
|
/* Looks like: hid:bNvNpN */
|
|
|
|
static int do_hid_entry(const char *filename,
|
2013-01-21 00:58:47 +08:00
|
|
|
void *symval, char *alias)
|
2008-05-19 21:50:01 +08:00
|
|
|
{
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD(symval, hid_device_id, bus);
|
|
|
|
DEF_FIELD(symval, hid_device_id, group);
|
|
|
|
DEF_FIELD(symval, hid_device_id, vendor);
|
|
|
|
DEF_FIELD(symval, hid_device_id, product);
|
2008-05-19 21:50:01 +08:00
|
|
|
|
2012-04-23 18:07:04 +08:00
|
|
|
sprintf(alias, "hid:");
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD(alias, "b", bus != HID_BUS_ANY, bus);
|
|
|
|
ADD(alias, "g", group != HID_GROUP_ANY, group);
|
|
|
|
ADD(alias, "v", vendor != HID_ANY_ID, vendor);
|
|
|
|
ADD(alias, "p", product != HID_ANY_ID, product);
|
2008-05-19 21:50:01 +08:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("hid", hid_device_id, do_hid_entry);
|
2008-05-19 21:50:01 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* Looks like: ieee1394:venNmoNspNverN */
|
|
|
|
static int do_ieee1394_entry(const char *filename,
|
2013-01-21 00:58:47 +08:00
|
|
|
void *symval, char *alias)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD(symval, ieee1394_device_id, match_flags);
|
|
|
|
DEF_FIELD(symval, ieee1394_device_id, vendor_id);
|
|
|
|
DEF_FIELD(symval, ieee1394_device_id, model_id);
|
|
|
|
DEF_FIELD(symval, ieee1394_device_id, specifier_id);
|
|
|
|
DEF_FIELD(symval, ieee1394_device_id, version);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
strcpy(alias, "ieee1394:");
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD(alias, "ven", match_flags & IEEE1394_MATCH_VENDOR_ID,
|
|
|
|
vendor_id);
|
|
|
|
ADD(alias, "mo", match_flags & IEEE1394_MATCH_MODEL_ID,
|
|
|
|
model_id);
|
|
|
|
ADD(alias, "sp", match_flags & IEEE1394_MATCH_SPECIFIER_ID,
|
|
|
|
specifier_id);
|
|
|
|
ADD(alias, "ver", match_flags & IEEE1394_MATCH_VERSION,
|
|
|
|
version);
|
2005-04-17 06:20:36 +08: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-03 02:37:21 +08:00
|
|
|
add_wildcard(alias);
|
2005-04-17 06:20:36 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("ieee1394", ieee1394_device_id, do_ieee1394_entry);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Looks like: pci:vNdNsvNsdNbcNscNiN. */
|
|
|
|
static int do_pci_entry(const char *filename,
|
2013-01-21 00:58:47 +08:00
|
|
|
void *symval, char *alias)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
/* Class field can be divided into these three. */
|
|
|
|
unsigned char baseclass, subclass, interface,
|
|
|
|
baseclass_mask, subclass_mask, interface_mask;
|
|
|
|
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD(symval, pci_device_id, vendor);
|
|
|
|
DEF_FIELD(symval, pci_device_id, device);
|
|
|
|
DEF_FIELD(symval, pci_device_id, subvendor);
|
|
|
|
DEF_FIELD(symval, pci_device_id, subdevice);
|
|
|
|
DEF_FIELD(symval, pci_device_id, class);
|
|
|
|
DEF_FIELD(symval, pci_device_id, class_mask);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
strcpy(alias, "pci:");
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD(alias, "v", vendor != PCI_ANY_ID, vendor);
|
|
|
|
ADD(alias, "d", device != PCI_ANY_ID, device);
|
|
|
|
ADD(alias, "sv", subvendor != PCI_ANY_ID, subvendor);
|
|
|
|
ADD(alias, "sd", subdevice != PCI_ANY_ID, subdevice);
|
|
|
|
|
|
|
|
baseclass = (class) >> 16;
|
|
|
|
baseclass_mask = (class_mask) >> 16;
|
|
|
|
subclass = (class) >> 8;
|
|
|
|
subclass_mask = (class_mask) >> 8;
|
|
|
|
interface = class;
|
|
|
|
interface_mask = class_mask;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if ((baseclass_mask != 0 && baseclass_mask != 0xFF)
|
|
|
|
|| (subclass_mask != 0 && subclass_mask != 0xFF)
|
|
|
|
|| (interface_mask != 0 && interface_mask != 0xFF)) {
|
2006-01-28 23:57:26 +08:00
|
|
|
warn("Can't handle masks in %s:%04X\n",
|
2013-01-21 00:58:47 +08:00
|
|
|
filename, class_mask);
|
2005-04-17 06:20:36 +08: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-03 02:37:21 +08:00
|
|
|
add_wildcard(alias);
|
2005-04-17 06:20:36 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("pci", pci_device_id, do_pci_entry);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-03-03 23:46:04 +08:00
|
|
|
/* looks like: "ccw:tNmNdtNdmN" */
|
2005-04-17 06:20:36 +08:00
|
|
|
static int do_ccw_entry(const char *filename,
|
2013-01-21 00:58:47 +08:00
|
|
|
void *symval, char *alias)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD(symval, ccw_device_id, match_flags);
|
|
|
|
DEF_FIELD(symval, ccw_device_id, cu_type);
|
|
|
|
DEF_FIELD(symval, ccw_device_id, cu_model);
|
|
|
|
DEF_FIELD(symval, ccw_device_id, dev_type);
|
|
|
|
DEF_FIELD(symval, ccw_device_id, dev_model);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
strcpy(alias, "ccw:");
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD(alias, "t", match_flags&CCW_DEVICE_ID_MATCH_CU_TYPE,
|
|
|
|
cu_type);
|
|
|
|
ADD(alias, "m", match_flags&CCW_DEVICE_ID_MATCH_CU_MODEL,
|
|
|
|
cu_model);
|
|
|
|
ADD(alias, "dt", match_flags&CCW_DEVICE_ID_MATCH_DEVICE_TYPE,
|
|
|
|
dev_type);
|
|
|
|
ADD(alias, "dm", match_flags&CCW_DEVICE_ID_MATCH_DEVICE_MODEL,
|
|
|
|
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-03 02:37:21 +08:00
|
|
|
add_wildcard(alias);
|
2005-04-17 06:20:36 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("ccw", ccw_device_id, do_ccw_entry);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-09-20 21:58:25 +08:00
|
|
|
/* looks like: "ap:tN" */
|
|
|
|
static int do_ap_entry(const char *filename,
|
2013-01-21 00:58:47 +08:00
|
|
|
void *symval, char *alias)
|
2006-09-20 21:58:25 +08:00
|
|
|
{
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD(symval, ap_device_id, dev_type);
|
|
|
|
|
|
|
|
sprintf(alias, "ap:t%02X*", dev_type);
|
2006-09-20 21:58:25 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("ap", ap_device_id, do_ap_entry);
|
2006-09-20 21:58:25 +08:00
|
|
|
|
2008-07-14 15:58:44 +08:00
|
|
|
/* looks like: "css:tN" */
|
|
|
|
static int do_css_entry(const char *filename,
|
2013-01-21 00:58:47 +08:00
|
|
|
void *symval, char *alias)
|
2008-07-14 15:58:44 +08:00
|
|
|
{
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD(symval, css_device_id, type);
|
|
|
|
|
|
|
|
sprintf(alias, "css:t%01X", type);
|
2008-07-14 15:58:44 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("css", css_device_id, do_css_entry);
|
2008-07-14 15:58:44 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* Looks like: "serio:tyNprNidNexN" */
|
|
|
|
static int do_serio_entry(const char *filename,
|
2013-01-21 00:58:47 +08:00
|
|
|
void *symval, char *alias)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD(symval, serio_device_id, type);
|
|
|
|
DEF_FIELD(symval, serio_device_id, proto);
|
|
|
|
DEF_FIELD(symval, serio_device_id, id);
|
|
|
|
DEF_FIELD(symval, serio_device_id, extra);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
strcpy(alias, "serio:");
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD(alias, "ty", type != SERIO_ANY, type);
|
|
|
|
ADD(alias, "pr", proto != SERIO_ANY, proto);
|
|
|
|
ADD(alias, "id", id != SERIO_ANY, id);
|
|
|
|
ADD(alias, "ex", extra != SERIO_ANY, extra);
|
2005-04-17 06:20:36 +08: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-03 02:37:21 +08:00
|
|
|
add_wildcard(alias);
|
2005-04-17 06:20:36 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("serio", serio_device_id, do_serio_entry);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
ACPI / scan: Add support for ACPI _CLS device matching
Device drivers typically use ACPI _HIDs/_CIDs listed in struct device_driver
acpi_match_table to match devices. However, for generic drivers, we do not
want to list _HID for all supported devices. Also, certain classes of devices
do not have _CID (e.g. SATA, USB). Instead, we can leverage ACPI _CLS,
which specifies PCI-defined class code (i.e. base-class, subclass and
programming interface). This patch adds support for matching ACPI devices using
the _CLS method.
To support loadable module, current design uses _HID or _CID to match device's
modalias. With the new way of matching with _CLS this would requires modification
to the current ACPI modalias key to include _CLS. This patch appends PCI-defined
class-code to the existing ACPI modalias as following.
acpi:<HID>:<CID1>:<CID2>:..:<CIDn>:<bbsspp>:
E.g:
# cat /sys/devices/platform/AMDI0600:00/modalias
acpi:AMDI0600:010601:
where bb is th base-class code, ss is te sub-class code, and pp is the
programming interface code
Since there would not be _HID/_CID in the ACPI matching table of the driver,
this patch adds a field to acpi_device_id to specify the matching _CLS.
static const struct acpi_device_id ahci_acpi_match[] = {
{ ACPI_DEVICE_CLASS(PCI_CLASS_STORAGE_SATA_AHCI, 0xffffff) },
{},
};
In this case, the corresponded entry in modules.alias file would be:
alias acpi*:010601:* ahci_platform
Acked-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Reviewed-by: Hanjun Guo <hanjun.guo@linaro.org>
Signed-off-by: Suravee Suthikulpanit <Suravee.Suthikulpanit@amd.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2015-07-07 07:55:20 +08:00
|
|
|
/* looks like: "acpi:ACPI0003" or "acpi:PNP0C0B" or "acpi:LNXVIDEO" or
|
|
|
|
* "acpi:bbsspp" (bb=base-class, ss=sub-class, pp=prog-if)
|
|
|
|
*
|
|
|
|
* NOTE: Each driver should use one of the following : _HID, _CIDs
|
|
|
|
* or _CLS. Also, bb, ss, and pp can be substituted with ??
|
|
|
|
* as don't care byte.
|
|
|
|
*/
|
2007-07-23 20:43:51 +08:00
|
|
|
static int do_acpi_entry(const char *filename,
|
2013-01-21 00:58:47 +08:00
|
|
|
void *symval, char *alias)
|
2007-07-23 20:43:51 +08:00
|
|
|
{
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD_ADDR(symval, acpi_device_id, id);
|
ACPI / scan: Add support for ACPI _CLS device matching
Device drivers typically use ACPI _HIDs/_CIDs listed in struct device_driver
acpi_match_table to match devices. However, for generic drivers, we do not
want to list _HID for all supported devices. Also, certain classes of devices
do not have _CID (e.g. SATA, USB). Instead, we can leverage ACPI _CLS,
which specifies PCI-defined class code (i.e. base-class, subclass and
programming interface). This patch adds support for matching ACPI devices using
the _CLS method.
To support loadable module, current design uses _HID or _CID to match device's
modalias. With the new way of matching with _CLS this would requires modification
to the current ACPI modalias key to include _CLS. This patch appends PCI-defined
class-code to the existing ACPI modalias as following.
acpi:<HID>:<CID1>:<CID2>:..:<CIDn>:<bbsspp>:
E.g:
# cat /sys/devices/platform/AMDI0600:00/modalias
acpi:AMDI0600:010601:
where bb is th base-class code, ss is te sub-class code, and pp is the
programming interface code
Since there would not be _HID/_CID in the ACPI matching table of the driver,
this patch adds a field to acpi_device_id to specify the matching _CLS.
static const struct acpi_device_id ahci_acpi_match[] = {
{ ACPI_DEVICE_CLASS(PCI_CLASS_STORAGE_SATA_AHCI, 0xffffff) },
{},
};
In this case, the corresponded entry in modules.alias file would be:
alias acpi*:010601:* ahci_platform
Acked-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Reviewed-by: Hanjun Guo <hanjun.guo@linaro.org>
Signed-off-by: Suravee Suthikulpanit <Suravee.Suthikulpanit@amd.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2015-07-07 07:55:20 +08:00
|
|
|
DEF_FIELD_ADDR(symval, acpi_device_id, cls);
|
|
|
|
DEF_FIELD_ADDR(symval, acpi_device_id, cls_msk);
|
|
|
|
|
|
|
|
if (id && strlen((const char *)*id))
|
|
|
|
sprintf(alias, "acpi*:%s:*", *id);
|
|
|
|
else if (cls) {
|
|
|
|
int i, byte_shift, cnt = 0;
|
|
|
|
unsigned int msk;
|
|
|
|
|
|
|
|
sprintf(&alias[cnt], "acpi*:");
|
|
|
|
cnt = 6;
|
|
|
|
for (i = 1; i <= 3; i++) {
|
|
|
|
byte_shift = 8 * (3-i);
|
|
|
|
msk = (*cls_msk >> byte_shift) & 0xFF;
|
|
|
|
if (msk)
|
|
|
|
sprintf(&alias[cnt], "%02x",
|
|
|
|
(*cls >> byte_shift) & 0xFF);
|
|
|
|
else
|
|
|
|
sprintf(&alias[cnt], "??");
|
|
|
|
cnt += 2;
|
|
|
|
}
|
|
|
|
sprintf(&alias[cnt], ":*");
|
|
|
|
}
|
2007-07-23 20:43:51 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("acpi", acpi_device_id, do_acpi_entry);
|
2007-07-23 20:43:51 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* looks like: "pnp:dD" */
|
2008-05-29 05:06:47 +08:00
|
|
|
static void do_pnp_device_entry(void *symval, unsigned long size,
|
|
|
|
struct module *mod)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2013-01-21 00:58:47 +08:00
|
|
|
const unsigned long id_size = SIZE_pnp_device_id;
|
2008-08-21 21:28:56 +08:00
|
|
|
const unsigned int count = (size / id_size)-1;
|
|
|
|
unsigned int i;
|
2008-05-29 05:06:47 +08:00
|
|
|
|
|
|
|
device_id_check(mod->name, "pnp", size, id_size, symval);
|
|
|
|
|
2008-08-21 21:28:56 +08:00
|
|
|
for (i = 0; i < count; i++) {
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD_ADDR(symval + i*id_size, pnp_device_id, id);
|
|
|
|
char acpi_id[sizeof(*id)];
|
2009-01-08 10:06:42 +08:00
|
|
|
int j;
|
2008-08-21 21:28:56 +08:00
|
|
|
|
|
|
|
buf_printf(&mod->dev_table_buf,
|
2013-01-21 00:58:47 +08:00
|
|
|
"MODULE_ALIAS(\"pnp:d%s*\");\n", *id);
|
2009-01-08 10:06:42 +08:00
|
|
|
|
|
|
|
/* fix broken pnp bus lowercasing */
|
|
|
|
for (j = 0; j < sizeof(acpi_id); j++)
|
2013-01-21 00:58:47 +08:00
|
|
|
acpi_id[j] = toupper((*id)[j]);
|
2008-08-21 21:28:56 +08:00
|
|
|
buf_printf(&mod->dev_table_buf,
|
2009-01-08 10:06:42 +08:00
|
|
|
"MODULE_ALIAS(\"acpi*:%s:*\");\n", acpi_id);
|
2008-08-21 21:28:56 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-02-21 07:35:54 +08: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 06:20:36 +08:00
|
|
|
{
|
2013-01-21 00:58:47 +08:00
|
|
|
const unsigned long id_size = SIZE_pnp_card_device_id;
|
2008-02-21 07:35:54 +08:00
|
|
|
const unsigned int count = (size / id_size)-1;
|
|
|
|
unsigned int i;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-02-21 07:35:54 +08:00
|
|
|
device_id_check(mod->name, "pnp", size, id_size, symval);
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
unsigned int j;
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD_ADDR(symval + i*id_size, pnp_card_device_id, devs);
|
2008-02-21 07:35:54 +08:00
|
|
|
|
|
|
|
for (j = 0; j < PNP_MAX_DEVICES; j++) {
|
2013-01-21 00:58:47 +08:00
|
|
|
const char *id = (char *)(*devs)[j].id;
|
2008-02-21 07:35:54 +08:00
|
|
|
int i2, j2;
|
|
|
|
int dup = 0;
|
|
|
|
|
|
|
|
if (!id[0])
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* find duplicate, already added value */
|
|
|
|
for (i2 = 0; i2 < i && !dup; i2++) {
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD_ADDR(symval + i2*id_size, pnp_card_device_id, devs);
|
2008-02-21 07:35:54 +08:00
|
|
|
|
|
|
|
for (j2 = 0; j2 < PNP_MAX_DEVICES; j2++) {
|
2013-01-21 00:58:47 +08:00
|
|
|
const char *id2 = (char *)(*devs)[j2].id;
|
2008-02-21 07:35:54 +08:00
|
|
|
|
|
|
|
if (!id2[0])
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (!strcmp(id, id2)) {
|
|
|
|
dup = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* add an individual alias for every device entry */
|
2008-05-29 05:06:47 +08:00
|
|
|
if (!dup) {
|
2013-01-21 00:58:47 +08:00
|
|
|
char acpi_id[PNP_ID_LEN];
|
2009-01-08 10:06:42 +08:00
|
|
|
int k;
|
|
|
|
|
2008-02-21 07:35:54 +08:00
|
|
|
buf_printf(&mod->dev_table_buf,
|
|
|
|
"MODULE_ALIAS(\"pnp:d%s*\");\n", id);
|
2009-01-08 10:06:42 +08:00
|
|
|
|
|
|
|
/* fix broken pnp bus lowercasing */
|
|
|
|
for (k = 0; k < sizeof(acpi_id); k++)
|
|
|
|
acpi_id[k] = toupper(id[k]);
|
2008-05-29 05:06:47 +08:00
|
|
|
buf_printf(&mod->dev_table_buf,
|
2009-01-08 10:06:42 +08:00
|
|
|
"MODULE_ALIAS(\"acpi*:%s:*\");\n", acpi_id);
|
2008-05-29 05:06:47 +08:00
|
|
|
}
|
2008-02-21 07:35:54 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-06-28 07:28:12 +08:00
|
|
|
/* Looks like: pcmcia:mNcNfNfnNpfnNvaNvbNvcNvdN. */
|
|
|
|
static int do_pcmcia_entry(const char *filename,
|
2013-01-21 00:58:47 +08:00
|
|
|
void *symval, char *alias)
|
2005-06-28 07:28:12 +08:00
|
|
|
{
|
|
|
|
unsigned int i;
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD(symval, pcmcia_device_id, match_flags);
|
|
|
|
DEF_FIELD(symval, pcmcia_device_id, manf_id);
|
|
|
|
DEF_FIELD(symval, pcmcia_device_id, card_id);
|
|
|
|
DEF_FIELD(symval, pcmcia_device_id, func_id);
|
|
|
|
DEF_FIELD(symval, pcmcia_device_id, function);
|
|
|
|
DEF_FIELD(symval, pcmcia_device_id, device_no);
|
|
|
|
DEF_FIELD_ADDR(symval, pcmcia_device_id, prod_id_hash);
|
2005-09-25 20:39:46 +08:00
|
|
|
|
2005-06-28 07:28:12 +08:00
|
|
|
for (i=0; i<4; i++) {
|
2013-01-21 00:58:47 +08:00
|
|
|
(*prod_id_hash)[i] = TO_NATIVE((*prod_id_hash)[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
strcpy(alias, "pcmcia:");
|
|
|
|
ADD(alias, "m", match_flags & PCMCIA_DEV_ID_MATCH_MANF_ID,
|
|
|
|
manf_id);
|
|
|
|
ADD(alias, "c", match_flags & PCMCIA_DEV_ID_MATCH_CARD_ID,
|
|
|
|
card_id);
|
|
|
|
ADD(alias, "f", match_flags & PCMCIA_DEV_ID_MATCH_FUNC_ID,
|
|
|
|
func_id);
|
|
|
|
ADD(alias, "fn", match_flags & PCMCIA_DEV_ID_MATCH_FUNCTION,
|
|
|
|
function);
|
|
|
|
ADD(alias, "pfn", match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO,
|
|
|
|
device_no);
|
|
|
|
ADD(alias, "pa", match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID1, (*prod_id_hash)[0]);
|
|
|
|
ADD(alias, "pb", match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID2, (*prod_id_hash)[1]);
|
|
|
|
ADD(alias, "pc", match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID3, (*prod_id_hash)[2]);
|
|
|
|
ADD(alias, "pd", match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID4, (*prod_id_hash)[3]);
|
2005-06-28 07:28:12 +08: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-03 02:37:21 +08:00
|
|
|
add_wildcard(alias);
|
2013-01-21 00:58:47 +08:00
|
|
|
return 1;
|
2005-06-28 07:28:12 +08:00
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("pcmcia", pcmcia_device_id, do_pcmcia_entry);
|
2005-06-28 07:28:12 +08:00
|
|
|
|
2013-01-21 00:58:47 +08:00
|
|
|
static int do_vio_entry(const char *filename, void *symval,
|
2005-08-17 14:42:59 +08:00
|
|
|
char *alias)
|
|
|
|
{
|
|
|
|
char *tmp;
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD_ADDR(symval, vio_device_id, type);
|
|
|
|
DEF_FIELD_ADDR(symval, vio_device_id, compat);
|
2005-08-17 14:42:59 +08:00
|
|
|
|
2013-01-21 00:58:47 +08:00
|
|
|
sprintf(alias, "vio:T%sS%s", (*type)[0] ? *type : "*",
|
|
|
|
(*compat)[0] ? *compat : "*");
|
2005-08-17 14:42:59 +08: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-03 02:37:21 +08:00
|
|
|
add_wildcard(alias);
|
2005-08-17 14:42:59 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("vio", vio_device_id, do_vio_entry);
|
2005-08-17 14:42:59 +08:00
|
|
|
|
2005-12-08 04:40:34 +08: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 12:14:19 +08:00
|
|
|
|
2013-01-21 00:58:47 +08:00
|
|
|
for (i = min / BITS_PER_LONG; i < max / BITS_PER_LONG + 1; i++)
|
|
|
|
arr[i] = TO_NATIVE(arr[i]);
|
2006-04-26 12:14:19 +08: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 18:09:27 +08:00
|
|
|
if (arr[i / BITS_PER_LONG] & (1L << (i%BITS_PER_LONG)))
|
2006-04-26 12:14:19 +08:00
|
|
|
sprintf(alias + strlen(alias), "%X,*", i);
|
2005-12-08 04:40:34 +08:00
|
|
|
}
|
|
|
|
|
2017-10-23 02:42:29 +08:00
|
|
|
/* input:b0v0p0e0-eXkXrXaXmXlXsXfXwX where X is comma-separated %02X. */
|
2013-01-21 00:58:47 +08:00
|
|
|
static int do_input_entry(const char *filename, void *symval,
|
2005-12-08 04:40:34 +08:00
|
|
|
char *alias)
|
|
|
|
{
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD(symval, input_device_id, flags);
|
|
|
|
DEF_FIELD(symval, input_device_id, bustype);
|
|
|
|
DEF_FIELD(symval, input_device_id, vendor);
|
|
|
|
DEF_FIELD(symval, input_device_id, product);
|
|
|
|
DEF_FIELD(symval, input_device_id, version);
|
|
|
|
DEF_FIELD_ADDR(symval, input_device_id, evbit);
|
|
|
|
DEF_FIELD_ADDR(symval, input_device_id, keybit);
|
|
|
|
DEF_FIELD_ADDR(symval, input_device_id, relbit);
|
|
|
|
DEF_FIELD_ADDR(symval, input_device_id, absbit);
|
|
|
|
DEF_FIELD_ADDR(symval, input_device_id, mscbit);
|
|
|
|
DEF_FIELD_ADDR(symval, input_device_id, ledbit);
|
|
|
|
DEF_FIELD_ADDR(symval, input_device_id, sndbit);
|
|
|
|
DEF_FIELD_ADDR(symval, input_device_id, ffbit);
|
|
|
|
DEF_FIELD_ADDR(symval, input_device_id, swbit);
|
|
|
|
|
2005-12-08 04:40:34 +08:00
|
|
|
sprintf(alias, "input:");
|
|
|
|
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD(alias, "b", flags & INPUT_DEVICE_ID_MATCH_BUS, bustype);
|
|
|
|
ADD(alias, "v", flags & INPUT_DEVICE_ID_MATCH_VENDOR, vendor);
|
|
|
|
ADD(alias, "p", flags & INPUT_DEVICE_ID_MATCH_PRODUCT, product);
|
|
|
|
ADD(alias, "e", flags & INPUT_DEVICE_ID_MATCH_VERSION, version);
|
2005-12-08 04:40:34 +08:00
|
|
|
|
|
|
|
sprintf(alias + strlen(alias), "-e*");
|
2013-01-21 00:58:47 +08:00
|
|
|
if (flags & INPUT_DEVICE_ID_MATCH_EVBIT)
|
|
|
|
do_input(alias, *evbit, 0, INPUT_DEVICE_ID_EV_MAX);
|
2005-12-08 04:40:34 +08:00
|
|
|
sprintf(alias + strlen(alias), "k*");
|
2013-01-21 00:58:47 +08:00
|
|
|
if (flags & INPUT_DEVICE_ID_MATCH_KEYBIT)
|
|
|
|
do_input(alias, *keybit,
|
2007-03-10 02:59:06 +08:00
|
|
|
INPUT_DEVICE_ID_KEY_MIN_INTERESTING,
|
|
|
|
INPUT_DEVICE_ID_KEY_MAX);
|
2005-12-08 04:40:34 +08:00
|
|
|
sprintf(alias + strlen(alias), "r*");
|
2013-01-21 00:58:47 +08:00
|
|
|
if (flags & INPUT_DEVICE_ID_MATCH_RELBIT)
|
|
|
|
do_input(alias, *relbit, 0, INPUT_DEVICE_ID_REL_MAX);
|
2005-12-08 04:40:34 +08:00
|
|
|
sprintf(alias + strlen(alias), "a*");
|
2013-01-21 00:58:47 +08:00
|
|
|
if (flags & INPUT_DEVICE_ID_MATCH_ABSBIT)
|
|
|
|
do_input(alias, *absbit, 0, INPUT_DEVICE_ID_ABS_MAX);
|
2005-12-08 04:40:34 +08:00
|
|
|
sprintf(alias + strlen(alias), "m*");
|
2013-01-21 00:58:47 +08:00
|
|
|
if (flags & INPUT_DEVICE_ID_MATCH_MSCIT)
|
|
|
|
do_input(alias, *mscbit, 0, INPUT_DEVICE_ID_MSC_MAX);
|
2005-12-08 04:40:34 +08:00
|
|
|
sprintf(alias + strlen(alias), "l*");
|
2013-01-21 00:58:47 +08:00
|
|
|
if (flags & INPUT_DEVICE_ID_MATCH_LEDBIT)
|
|
|
|
do_input(alias, *ledbit, 0, INPUT_DEVICE_ID_LED_MAX);
|
2005-12-08 04:40:34 +08:00
|
|
|
sprintf(alias + strlen(alias), "s*");
|
2013-01-21 00:58:47 +08:00
|
|
|
if (flags & INPUT_DEVICE_ID_MATCH_SNDBIT)
|
|
|
|
do_input(alias, *sndbit, 0, INPUT_DEVICE_ID_SND_MAX);
|
2005-12-08 04:40:34 +08:00
|
|
|
sprintf(alias + strlen(alias), "f*");
|
2013-01-21 00:58:47 +08:00
|
|
|
if (flags & INPUT_DEVICE_ID_MATCH_FFBIT)
|
|
|
|
do_input(alias, *ffbit, 0, INPUT_DEVICE_ID_FF_MAX);
|
2005-12-08 04:40:34 +08:00
|
|
|
sprintf(alias + strlen(alias), "w*");
|
2013-01-21 00:58:47 +08:00
|
|
|
if (flags & INPUT_DEVICE_ID_MATCH_SWBIT)
|
|
|
|
do_input(alias, *swbit, 0, INPUT_DEVICE_ID_SW_MAX);
|
2005-12-08 04:40:34 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("input", input_device_id, do_input_entry);
|
2005-12-08 04:40:34 +08:00
|
|
|
|
2013-01-21 00:58:47 +08:00
|
|
|
static int do_eisa_entry(const char *filename, void *symval,
|
2006-09-27 16:50:56 +08:00
|
|
|
char *alias)
|
|
|
|
{
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD_ADDR(symval, eisa_device_id, sig);
|
|
|
|
if (sig[0])
|
|
|
|
sprintf(alias, EISA_DEVICE_MODALIAS_FMT "*", *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-03 02:37:21 +08:00
|
|
|
else
|
|
|
|
strcat(alias, "*");
|
2006-09-27 16:50:56 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("eisa", eisa_device_id, do_eisa_entry);
|
2006-09-27 16:50:56 +08:00
|
|
|
|
2007-01-14 03:58:21 +08:00
|
|
|
/* Looks like: parisc:tNhvNrevNsvN */
|
2013-01-21 00:58:47 +08:00
|
|
|
static int do_parisc_entry(const char *filename, void *symval,
|
2007-01-14 03:58:21 +08:00
|
|
|
char *alias)
|
|
|
|
{
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD(symval, parisc_device_id, hw_type);
|
|
|
|
DEF_FIELD(symval, parisc_device_id, hversion);
|
|
|
|
DEF_FIELD(symval, parisc_device_id, hversion_rev);
|
|
|
|
DEF_FIELD(symval, parisc_device_id, sversion);
|
2007-01-14 03:58:21 +08:00
|
|
|
|
|
|
|
strcpy(alias, "parisc:");
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD(alias, "t", hw_type != PA_HWTYPE_ANY_ID, hw_type);
|
|
|
|
ADD(alias, "hv", hversion != PA_HVERSION_ANY_ID, hversion);
|
|
|
|
ADD(alias, "rev", hversion_rev != PA_HVERSION_REV_ANY_ID, hversion_rev);
|
|
|
|
ADD(alias, "sv", sversion != PA_SVERSION_ANY_ID, sversion);
|
2007-01-14 03:58:21 +08: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-03 02:37:21 +08:00
|
|
|
add_wildcard(alias);
|
2007-01-14 03:58:21 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("parisc", parisc_device_id, do_parisc_entry);
|
2007-01-14 03:58:21 +08:00
|
|
|
|
2007-06-17 17:34:23 +08:00
|
|
|
/* Looks like: sdio:cNvNdN. */
|
|
|
|
static int do_sdio_entry(const char *filename,
|
2013-01-21 00:58:47 +08:00
|
|
|
void *symval, char *alias)
|
2007-06-17 17:34:23 +08:00
|
|
|
{
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD(symval, sdio_device_id, class);
|
|
|
|
DEF_FIELD(symval, sdio_device_id, vendor);
|
|
|
|
DEF_FIELD(symval, sdio_device_id, device);
|
2007-06-17 17:34:23 +08:00
|
|
|
|
|
|
|
strcpy(alias, "sdio:");
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD(alias, "c", class != (__u8)SDIO_ANY_ID, class);
|
|
|
|
ADD(alias, "v", vendor != (__u16)SDIO_ANY_ID, vendor);
|
|
|
|
ADD(alias, "d", device != (__u16)SDIO_ANY_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-03 02:37:21 +08:00
|
|
|
add_wildcard(alias);
|
2007-10-12 10:40:14 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("sdio", sdio_device_id, do_sdio_entry);
|
2007-10-12 10:40:14 +08:00
|
|
|
|
2007-09-19 03:12:50 +08:00
|
|
|
/* Looks like: ssb:vNidNrevN. */
|
|
|
|
static int do_ssb_entry(const char *filename,
|
2013-01-21 00:58:47 +08:00
|
|
|
void *symval, char *alias)
|
2007-09-19 03:12:50 +08:00
|
|
|
{
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD(symval, ssb_device_id, vendor);
|
|
|
|
DEF_FIELD(symval, ssb_device_id, coreid);
|
|
|
|
DEF_FIELD(symval, ssb_device_id, revision);
|
2007-06-17 17:34:23 +08:00
|
|
|
|
2007-09-19 03:12:50 +08:00
|
|
|
strcpy(alias, "ssb:");
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD(alias, "v", vendor != SSB_ANY_VENDOR, vendor);
|
|
|
|
ADD(alias, "id", coreid != SSB_ANY_ID, coreid);
|
|
|
|
ADD(alias, "rev", revision != SSB_ANY_REV, 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-03 02:37:21 +08:00
|
|
|
add_wildcard(alias);
|
2007-06-17 17:34:23 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("ssb", ssb_device_id, do_ssb_entry);
|
2007-06-17 17:34:23 +08:00
|
|
|
|
2011-05-10 00:56:46 +08:00
|
|
|
/* Looks like: bcma:mNidNrevNclN. */
|
|
|
|
static int do_bcma_entry(const char *filename,
|
2013-01-21 00:58:47 +08:00
|
|
|
void *symval, char *alias)
|
2011-05-10 00:56:46 +08:00
|
|
|
{
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD(symval, bcma_device_id, manuf);
|
|
|
|
DEF_FIELD(symval, bcma_device_id, id);
|
|
|
|
DEF_FIELD(symval, bcma_device_id, rev);
|
|
|
|
DEF_FIELD(symval, bcma_device_id, class);
|
2011-05-10 00:56:46 +08:00
|
|
|
|
|
|
|
strcpy(alias, "bcma:");
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD(alias, "m", manuf != BCMA_ANY_MANUF, manuf);
|
|
|
|
ADD(alias, "id", id != BCMA_ANY_ID, id);
|
|
|
|
ADD(alias, "rev", rev != BCMA_ANY_REV, rev);
|
|
|
|
ADD(alias, "cl", class != BCMA_ANY_CLASS, class);
|
2011-05-10 00:56:46 +08:00
|
|
|
add_wildcard(alias);
|
|
|
|
return 1;
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("bcma", bcma_device_id, do_bcma_entry);
|
2011-05-10 00:56:46 +08:00
|
|
|
|
2007-10-22 09:03:39 +08:00
|
|
|
/* Looks like: virtio:dNvN */
|
2013-01-21 00:58:47 +08:00
|
|
|
static int do_virtio_entry(const char *filename, void *symval,
|
2007-10-22 09:03:39 +08:00
|
|
|
char *alias)
|
|
|
|
{
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD(symval, virtio_device_id, device);
|
|
|
|
DEF_FIELD(symval, virtio_device_id, vendor);
|
2007-10-22 09:03:39 +08:00
|
|
|
|
|
|
|
strcpy(alias, "virtio:");
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD(alias, "d", device != VIRTIO_DEV_ANY_ID, device);
|
|
|
|
ADD(alias, "v", vendor != VIRTIO_DEV_ANY_ID, vendor);
|
2007-10-22 09:03:39 +08: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-03 02:37:21 +08:00
|
|
|
add_wildcard(alias);
|
2007-10-22 09:03:39 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("virtio", virtio_device_id, do_virtio_entry);
|
2007-10-22 09:03:39 +08:00
|
|
|
|
2011-08-26 00:48:30 +08:00
|
|
|
/*
|
|
|
|
* Looks like: vmbus:guid
|
|
|
|
* Each byte of the guid will be represented by two hex characters
|
|
|
|
* in the name.
|
|
|
|
*/
|
|
|
|
|
2013-01-21 00:58:47 +08:00
|
|
|
static int do_vmbus_entry(const char *filename, void *symval,
|
2011-08-26 00:48:30 +08:00
|
|
|
char *alias)
|
|
|
|
{
|
|
|
|
int i;
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD_ADDR(symval, hv_vmbus_device_id, guid);
|
|
|
|
char guid_name[(sizeof(*guid) + 1) * 2];
|
2011-08-26 00:48:30 +08:00
|
|
|
|
2013-01-21 00:58:47 +08:00
|
|
|
for (i = 0; i < (sizeof(*guid) * 2); i += 2)
|
2015-12-15 08:01:43 +08:00
|
|
|
sprintf(&guid_name[i], "%02x", TO_NATIVE((guid->b)[i/2]));
|
2011-08-26 00:48:30 +08:00
|
|
|
|
|
|
|
strcpy(alias, "vmbus:");
|
|
|
|
strcat(alias, guid_name);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("vmbus", hv_vmbus_device_id, do_vmbus_entry);
|
2011-08-26 00:48:30 +08:00
|
|
|
|
2018-04-22 07:55:29 +08:00
|
|
|
/* Looks like: rpmsg:S */
|
|
|
|
static int do_rpmsg_entry(const char *filename, void *symval,
|
|
|
|
char *alias)
|
|
|
|
{
|
|
|
|
DEF_FIELD_ADDR(symval, rpmsg_device_id, name);
|
|
|
|
sprintf(alias, RPMSG_DEVICE_MODALIAS_FMT, *name);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
ADD_TO_DEVTABLE("rpmsg", rpmsg_device_id, do_rpmsg_entry);
|
|
|
|
|
2008-04-30 05:11:39 +08:00
|
|
|
/* Looks like: i2c:S */
|
2013-01-21 00:58:47 +08:00
|
|
|
static int do_i2c_entry(const char *filename, void *symval,
|
2008-04-30 05:11:39 +08:00
|
|
|
char *alias)
|
|
|
|
{
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD_ADDR(symval, i2c_device_id, name);
|
|
|
|
sprintf(alias, I2C_MODULE_PREFIX "%s", *name);
|
2008-04-30 05:11:39 +08:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("i2c", i2c_device_id, do_i2c_entry);
|
2008-04-30 05:11:39 +08:00
|
|
|
|
2009-09-23 07:46:08 +08:00
|
|
|
/* Looks like: spi:S */
|
2013-01-21 00:58:47 +08:00
|
|
|
static int do_spi_entry(const char *filename, void *symval,
|
2009-09-23 07:46:04 +08:00
|
|
|
char *alias)
|
|
|
|
{
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD_ADDR(symval, spi_device_id, name);
|
|
|
|
sprintf(alias, SPI_MODULE_PREFIX "%s", *name);
|
2009-09-23 07:46:04 +08:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("spi", spi_device_id, do_spi_entry);
|
2009-09-23 07:46:04 +08:00
|
|
|
|
2008-09-17 07:23:28 +08:00
|
|
|
static const struct dmifield {
|
|
|
|
const char *prefix;
|
|
|
|
int field;
|
|
|
|
} dmi_fields[] = {
|
|
|
|
{ "bvn", DMI_BIOS_VENDOR },
|
|
|
|
{ "bvr", DMI_BIOS_VERSION },
|
|
|
|
{ "bd", DMI_BIOS_DATE },
|
|
|
|
{ "svn", DMI_SYS_VENDOR },
|
|
|
|
{ "pn", DMI_PRODUCT_NAME },
|
|
|
|
{ "pvr", DMI_PRODUCT_VERSION },
|
|
|
|
{ "rvn", DMI_BOARD_VENDOR },
|
|
|
|
{ "rn", DMI_BOARD_NAME },
|
|
|
|
{ "rvr", DMI_BOARD_VERSION },
|
|
|
|
{ "cvn", DMI_CHASSIS_VENDOR },
|
|
|
|
{ "ct", DMI_CHASSIS_TYPE },
|
|
|
|
{ "cvr", DMI_CHASSIS_VERSION },
|
|
|
|
{ NULL, DMI_NONE }
|
|
|
|
};
|
|
|
|
|
|
|
|
static void dmi_ascii_filter(char *d, const char *s)
|
|
|
|
{
|
|
|
|
/* Filter out characters we don't want to see in the modalias string */
|
|
|
|
for (; *s; s++)
|
|
|
|
if (*s > ' ' && *s < 127 && *s != ':')
|
|
|
|
*(d++) = *s;
|
|
|
|
|
|
|
|
*d = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-01-21 00:58:47 +08:00
|
|
|
static int do_dmi_entry(const char *filename, void *symval,
|
2008-09-17 07:23:28 +08:00
|
|
|
char *alias)
|
|
|
|
{
|
|
|
|
int i, j;
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD_ADDR(symval, dmi_system_id, matches);
|
2008-09-17 07:23:28 +08:00
|
|
|
sprintf(alias, "dmi*");
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(dmi_fields); i++) {
|
|
|
|
for (j = 0; j < 4; j++) {
|
2013-01-21 00:58:47 +08:00
|
|
|
if ((*matches)[j].slot &&
|
|
|
|
(*matches)[j].slot == dmi_fields[i].field) {
|
2008-09-17 07:23:28 +08:00
|
|
|
sprintf(alias + strlen(alias), ":%s*",
|
|
|
|
dmi_fields[i].prefix);
|
|
|
|
dmi_ascii_filter(alias + strlen(alias),
|
2013-01-21 00:58:47 +08:00
|
|
|
(*matches)[j].substr);
|
2008-09-17 07:23:28 +08:00
|
|
|
strcat(alias, "*");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
strcat(alias, ":");
|
|
|
|
return 1;
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("dmi", dmi_system_id, do_dmi_entry);
|
2009-02-04 11:52:40 +08:00
|
|
|
|
|
|
|
static int do_platform_entry(const char *filename,
|
2013-01-21 00:58:47 +08:00
|
|
|
void *symval, char *alias)
|
2009-02-04 11:52:40 +08:00
|
|
|
{
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD_ADDR(symval, platform_device_id, name);
|
|
|
|
sprintf(alias, PLATFORM_MODULE_PREFIX "%s", *name);
|
2009-02-04 11:52:40 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("platform", platform_device_id, do_platform_entry);
|
2009-02-04 11:52:40 +08:00
|
|
|
|
2010-04-02 09:05:27 +08:00
|
|
|
static int do_mdio_entry(const char *filename,
|
2013-01-21 00:58:47 +08:00
|
|
|
void *symval, char *alias)
|
2010-04-02 09:05:27 +08:00
|
|
|
{
|
|
|
|
int i;
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD(symval, mdio_device_id, phy_id);
|
|
|
|
DEF_FIELD(symval, mdio_device_id, phy_id_mask);
|
2010-04-02 09:05:27 +08:00
|
|
|
|
|
|
|
alias += sprintf(alias, MDIO_MODULE_PREFIX);
|
|
|
|
|
|
|
|
for (i = 0; i < 32; i++) {
|
2013-01-21 00:58:47 +08:00
|
|
|
if (!((phy_id_mask >> (31-i)) & 1))
|
2010-04-02 09:05:27 +08:00
|
|
|
*(alias++) = '?';
|
2013-01-21 00:58:47 +08:00
|
|
|
else if ((phy_id >> (31-i)) & 1)
|
2010-04-02 09:05:27 +08:00
|
|
|
*(alias++) = '1';
|
|
|
|
else
|
|
|
|
*(alias++) = '0';
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Terminate the string */
|
|
|
|
*alias = 0;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("mdio", mdio_device_id, do_mdio_entry);
|
2010-04-02 09:05:27 +08:00
|
|
|
|
2008-11-19 04:13:53 +08:00
|
|
|
/* Looks like: zorro:iN. */
|
2013-01-21 00:58:47 +08:00
|
|
|
static int do_zorro_entry(const char *filename, void *symval,
|
2008-11-19 04:13:53 +08:00
|
|
|
char *alias)
|
|
|
|
{
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD(symval, zorro_device_id, id);
|
2008-11-19 04:13:53 +08:00
|
|
|
strcpy(alias, "zorro:");
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD(alias, "i", id != ZORRO_WILDCARD, id);
|
2008-11-19 04:13:53 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("zorro", zorro_device_id, do_zorro_entry);
|
2008-11-19 04:13:53 +08:00
|
|
|
|
2009-12-19 03:52:39 +08:00
|
|
|
/* looks like: "pnp:dD" */
|
|
|
|
static int do_isapnp_entry(const char *filename,
|
2013-01-21 00:58:47 +08:00
|
|
|
void *symval, char *alias)
|
2009-12-19 03:52:39 +08:00
|
|
|
{
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD(symval, isapnp_device_id, vendor);
|
|
|
|
DEF_FIELD(symval, isapnp_device_id, function);
|
2009-12-19 03:52:39 +08:00
|
|
|
sprintf(alias, "pnp:d%c%c%c%x%x%x%x*",
|
2013-01-21 00:58:47 +08:00
|
|
|
'A' + ((vendor >> 2) & 0x3f) - 1,
|
|
|
|
'A' + (((vendor & 3) << 3) | ((vendor >> 13) & 7)) - 1,
|
|
|
|
'A' + ((vendor >> 8) & 0x1f) - 1,
|
|
|
|
(function >> 4) & 0x0f, function & 0x0f,
|
|
|
|
(function >> 12) & 0x0f, (function >> 8) & 0x0f);
|
2009-12-19 03:52:39 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("isapnp", isapnp_device_id, do_isapnp_entry);
|
2009-12-19 03:52:39 +08:00
|
|
|
|
2012-09-04 23:01:13 +08:00
|
|
|
/* Looks like: "ipack:fNvNdN". */
|
|
|
|
static int do_ipack_entry(const char *filename,
|
2013-01-21 00:58:47 +08:00
|
|
|
void *symval, char *alias)
|
2012-09-04 23:01:13 +08:00
|
|
|
{
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD(symval, ipack_device_id, format);
|
|
|
|
DEF_FIELD(symval, ipack_device_id, vendor);
|
|
|
|
DEF_FIELD(symval, ipack_device_id, device);
|
2012-09-04 23:01:13 +08:00
|
|
|
strcpy(alias, "ipack:");
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD(alias, "f", format != IPACK_ANY_FORMAT, format);
|
|
|
|
ADD(alias, "v", vendor != IPACK_ANY_ID, vendor);
|
|
|
|
ADD(alias, "d", device != IPACK_ANY_ID, device);
|
2012-09-04 23:01:13 +08:00
|
|
|
add_wildcard(alias);
|
|
|
|
return 1;
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("ipack", ipack_device_id, do_ipack_entry);
|
2012-09-04 23:01:13 +08:00
|
|
|
|
2011-10-05 21:44:57 +08:00
|
|
|
/*
|
|
|
|
* Append a match expression for a single masked hex digit.
|
|
|
|
* outp points to a pointer to the character at which to append.
|
|
|
|
* *outp is updated on return to point just after the appended text,
|
|
|
|
* to facilitate further appending.
|
|
|
|
*/
|
|
|
|
static void append_nibble_mask(char **outp,
|
|
|
|
unsigned int nibble, unsigned int mask)
|
|
|
|
{
|
|
|
|
char *p = *outp;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
switch (mask) {
|
|
|
|
case 0:
|
|
|
|
*p++ = '?';
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0xf:
|
|
|
|
p += sprintf(p, "%X", nibble);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
/*
|
|
|
|
* Dumbly emit a match pattern for all possible matching
|
|
|
|
* digits. This could be improved in some cases using ranges,
|
|
|
|
* but it has the advantage of being trivially correct, and is
|
|
|
|
* often optimal.
|
|
|
|
*/
|
|
|
|
*p++ = '[';
|
|
|
|
for (i = 0; i < 0x10; i++)
|
|
|
|
if ((i & mask) == nibble)
|
|
|
|
p += sprintf(p, "%X", i);
|
|
|
|
*p++ = ']';
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Ensure that the string remains NUL-terminated: */
|
|
|
|
*p = '\0';
|
|
|
|
|
|
|
|
/* Advance the caller's end-of-string pointer: */
|
|
|
|
*outp = p;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* looks like: "amba:dN"
|
|
|
|
*
|
|
|
|
* N is exactly 8 digits, where each is an upper-case hex digit, or
|
|
|
|
* a ? or [] pattern matching exactly one digit.
|
|
|
|
*/
|
|
|
|
static int do_amba_entry(const char *filename,
|
2013-01-21 00:58:47 +08:00
|
|
|
void *symval, char *alias)
|
2011-10-05 21:44:57 +08:00
|
|
|
{
|
|
|
|
unsigned int digit;
|
|
|
|
char *p = alias;
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD(symval, amba_id, id);
|
|
|
|
DEF_FIELD(symval, amba_id, mask);
|
2011-10-05 21:44:57 +08:00
|
|
|
|
2013-01-21 00:58:47 +08:00
|
|
|
if ((id & mask) != id)
|
2011-10-05 21:44:57 +08:00
|
|
|
fatal("%s: Masked-off bit(s) of AMBA device ID are non-zero: "
|
|
|
|
"id=0x%08X, mask=0x%08X. Please fix this driver.\n",
|
2013-01-21 00:58:47 +08:00
|
|
|
filename, id, mask);
|
2011-10-05 21:44:57 +08:00
|
|
|
|
|
|
|
p += sprintf(alias, "amba:d");
|
|
|
|
for (digit = 0; digit < 8; digit++)
|
|
|
|
append_nibble_mask(&p,
|
2013-01-21 00:58:47 +08:00
|
|
|
(id >> (4 * (7 - digit))) & 0xf,
|
|
|
|
(mask >> (4 * (7 - digit))) & 0xf);
|
2011-10-05 21:44:57 +08:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("amba", amba_id, do_amba_entry);
|
2011-10-05 21:44:57 +08:00
|
|
|
|
2015-03-25 23:39:50 +08:00
|
|
|
/*
|
|
|
|
* looks like: "mipscdmm:tN"
|
|
|
|
*
|
|
|
|
* N is exactly 2 digits, where each is an upper-case hex digit, or
|
|
|
|
* a ? or [] pattern matching exactly one digit.
|
|
|
|
*/
|
|
|
|
static int do_mips_cdmm_entry(const char *filename,
|
|
|
|
void *symval, char *alias)
|
|
|
|
{
|
|
|
|
DEF_FIELD(symval, mips_cdmm_device_id, type);
|
|
|
|
|
|
|
|
sprintf(alias, "mipscdmm:t%02X*", type);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
ADD_TO_DEVTABLE("mipscdmm", mips_cdmm_device_id, do_mips_cdmm_entry);
|
|
|
|
|
2014-02-08 20:34:10 +08:00
|
|
|
/* LOOKS like cpu:type:x86,venVVVVfamFFFFmodMMMM:feature:*,FEAT,*
|
2012-01-26 07:09:05 +08:00
|
|
|
* All fields are numbers. It would be nicer to use strings for vendor
|
|
|
|
* and feature, but getting those out of the build system here is too
|
|
|
|
* complicated.
|
|
|
|
*/
|
|
|
|
|
2013-01-21 00:58:47 +08:00
|
|
|
static int do_x86cpu_entry(const char *filename, void *symval,
|
2012-01-26 07:09:05 +08:00
|
|
|
char *alias)
|
|
|
|
{
|
2013-01-21 00:58:47 +08:00
|
|
|
DEF_FIELD(symval, x86_cpu_id, feature);
|
|
|
|
DEF_FIELD(symval, x86_cpu_id, family);
|
|
|
|
DEF_FIELD(symval, x86_cpu_id, model);
|
|
|
|
DEF_FIELD(symval, x86_cpu_id, vendor);
|
2012-01-26 07:09:05 +08:00
|
|
|
|
2014-02-08 20:34:10 +08:00
|
|
|
strcpy(alias, "cpu:type:x86,");
|
|
|
|
ADD(alias, "ven", vendor != X86_VENDOR_ANY, vendor);
|
|
|
|
ADD(alias, "fam", family != X86_FAMILY_ANY, family);
|
|
|
|
ADD(alias, "mod", model != X86_MODEL_ANY, model);
|
2012-02-12 06:57:19 +08:00
|
|
|
strcat(alias, ":feature:*");
|
2013-01-21 00:58:47 +08:00
|
|
|
if (feature != X86_FEATURE_ANY)
|
|
|
|
sprintf(alias + strlen(alias), "%04X*", feature);
|
2012-01-26 07:09:05 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2013-01-21 00:58:47 +08:00
|
|
|
ADD_TO_DEVTABLE("x86cpu", x86_cpu_id, do_x86cpu_entry);
|
2012-01-26 07:09:05 +08:00
|
|
|
|
2014-02-08 20:34:09 +08:00
|
|
|
/* LOOKS like cpu:type:*:feature:*FEAT* */
|
|
|
|
static int do_cpu_entry(const char *filename, void *symval, char *alias)
|
|
|
|
{
|
|
|
|
DEF_FIELD(symval, cpu_feature, feature);
|
|
|
|
|
|
|
|
sprintf(alias, "cpu:type:*:feature:*%04X*", feature);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
ADD_TO_DEVTABLE("cpu", cpu_feature, do_cpu_entry);
|
|
|
|
|
2015-09-10 15:18:01 +08:00
|
|
|
/* Looks like: mei:S:uuid:N:* */
|
2013-03-27 23:29:53 +08:00
|
|
|
static int do_mei_entry(const char *filename, void *symval,
|
|
|
|
char *alias)
|
|
|
|
{
|
|
|
|
DEF_FIELD_ADDR(symval, mei_cl_device_id, name);
|
2015-05-07 20:54:02 +08:00
|
|
|
DEF_FIELD_ADDR(symval, mei_cl_device_id, uuid);
|
2015-09-10 15:18:01 +08:00
|
|
|
DEF_FIELD(symval, mei_cl_device_id, version);
|
2015-05-07 20:54:02 +08:00
|
|
|
|
|
|
|
sprintf(alias, MEI_CL_MODULE_PREFIX);
|
|
|
|
sprintf(alias + strlen(alias), "%s:", (*name)[0] ? *name : "*");
|
|
|
|
add_uuid(alias, *uuid);
|
2015-09-10 15:18:01 +08:00
|
|
|
ADD(alias, ":", version != MEI_CL_VERSION_ANY, version);
|
2013-03-27 23:29:53 +08:00
|
|
|
|
2015-05-07 20:54:02 +08:00
|
|
|
strcat(alias, ":*");
|
2013-03-27 23:29:53 +08:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
ADD_TO_DEVTABLE("mei", mei_cl_device_id, do_mei_entry);
|
|
|
|
|
2013-07-04 06:08:58 +08:00
|
|
|
/* Looks like: rapidio:vNdNavNadN */
|
|
|
|
static int do_rio_entry(const char *filename,
|
|
|
|
void *symval, char *alias)
|
|
|
|
{
|
|
|
|
DEF_FIELD(symval, rio_device_id, did);
|
|
|
|
DEF_FIELD(symval, rio_device_id, vid);
|
|
|
|
DEF_FIELD(symval, rio_device_id, asm_did);
|
|
|
|
DEF_FIELD(symval, rio_device_id, asm_vid);
|
|
|
|
|
|
|
|
strcpy(alias, "rapidio:");
|
|
|
|
ADD(alias, "v", vid != RIO_ANY_ID, vid);
|
|
|
|
ADD(alias, "d", did != RIO_ANY_ID, did);
|
|
|
|
ADD(alias, "av", asm_vid != RIO_ANY_ID, asm_vid);
|
|
|
|
ADD(alias, "ad", asm_did != RIO_ANY_ID, asm_did);
|
|
|
|
|
|
|
|
add_wildcard(alias);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
ADD_TO_DEVTABLE("rapidio", rio_device_id, do_rio_entry);
|
|
|
|
|
2015-05-13 20:26:42 +08:00
|
|
|
/* Looks like: ulpi:vNpN */
|
|
|
|
static int do_ulpi_entry(const char *filename, void *symval,
|
|
|
|
char *alias)
|
|
|
|
{
|
|
|
|
DEF_FIELD(symval, ulpi_device_id, vendor);
|
|
|
|
DEF_FIELD(symval, ulpi_device_id, product);
|
|
|
|
|
|
|
|
sprintf(alias, "ulpi:v%04xp%04x", vendor, product);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
ADD_TO_DEVTABLE("ulpi", ulpi_device_id, do_ulpi_entry);
|
|
|
|
|
2015-09-29 16:26:10 +08:00
|
|
|
/* Looks like: hdaudio:vNrNaN */
|
|
|
|
static int do_hda_entry(const char *filename, void *symval, char *alias)
|
|
|
|
{
|
|
|
|
DEF_FIELD(symval, hda_device_id, vendor_id);
|
|
|
|
DEF_FIELD(symval, hda_device_id, rev_id);
|
|
|
|
DEF_FIELD(symval, hda_device_id, api_version);
|
|
|
|
|
|
|
|
strcpy(alias, "hdaudio:");
|
|
|
|
ADD(alias, "v", vendor_id != 0, vendor_id);
|
|
|
|
ADD(alias, "r", rev_id != 0, rev_id);
|
|
|
|
ADD(alias, "a", api_version != 0, api_version);
|
|
|
|
|
|
|
|
add_wildcard(alias);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
ADD_TO_DEVTABLE("hdaudio", hda_device_id, do_hda_entry);
|
|
|
|
|
2017-12-14 13:49:33 +08:00
|
|
|
/* Looks like: sdw:mNpN */
|
|
|
|
static int do_sdw_entry(const char *filename, void *symval, char *alias)
|
|
|
|
{
|
|
|
|
DEF_FIELD(symval, sdw_device_id, mfg_id);
|
|
|
|
DEF_FIELD(symval, sdw_device_id, part_id);
|
|
|
|
|
|
|
|
strcpy(alias, "sdw:");
|
|
|
|
ADD(alias, "m", mfg_id != 0, mfg_id);
|
|
|
|
ADD(alias, "p", part_id != 0, part_id);
|
|
|
|
|
|
|
|
add_wildcard(alias);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
ADD_TO_DEVTABLE("sdw", sdw_device_id, do_sdw_entry);
|
|
|
|
|
2016-06-23 05:40:45 +08:00
|
|
|
/* Looks like: fsl-mc:vNdN */
|
|
|
|
static int do_fsl_mc_entry(const char *filename, void *symval,
|
|
|
|
char *alias)
|
|
|
|
{
|
|
|
|
DEF_FIELD(symval, fsl_mc_device_id, vendor);
|
|
|
|
DEF_FIELD_ADDR(symval, fsl_mc_device_id, obj_type);
|
|
|
|
|
|
|
|
sprintf(alias, "fsl-mc:v%08Xd%s", vendor, *obj_type);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
ADD_TO_DEVTABLE("fslmc", fsl_mc_device_id, do_fsl_mc_entry);
|
|
|
|
|
2017-10-02 18:38:34 +08:00
|
|
|
/* Looks like: tbsvc:kSpNvNrN */
|
|
|
|
static int do_tbsvc_entry(const char *filename, void *symval, char *alias)
|
|
|
|
{
|
|
|
|
DEF_FIELD(symval, tb_service_id, match_flags);
|
|
|
|
DEF_FIELD_ADDR(symval, tb_service_id, protocol_key);
|
|
|
|
DEF_FIELD(symval, tb_service_id, protocol_id);
|
|
|
|
DEF_FIELD(symval, tb_service_id, protocol_version);
|
|
|
|
DEF_FIELD(symval, tb_service_id, protocol_revision);
|
|
|
|
|
|
|
|
strcpy(alias, "tbsvc:");
|
|
|
|
if (match_flags & TBSVC_MATCH_PROTOCOL_KEY)
|
|
|
|
sprintf(alias + strlen(alias), "k%s", *protocol_key);
|
|
|
|
else
|
|
|
|
strcat(alias + strlen(alias), "k*");
|
|
|
|
ADD(alias, "p", match_flags & TBSVC_MATCH_PROTOCOL_ID, protocol_id);
|
|
|
|
ADD(alias, "v", match_flags & TBSVC_MATCH_PROTOCOL_VERSION,
|
|
|
|
protocol_version);
|
|
|
|
ADD(alias, "r", match_flags & TBSVC_MATCH_PROTOCOL_REVISION,
|
|
|
|
protocol_revision);
|
|
|
|
|
|
|
|
add_wildcard(alias);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
ADD_TO_DEVTABLE("tbsvc", tb_service_id, do_tbsvc_entry);
|
|
|
|
|
2012-01-13 07:02:15 +08:00
|
|
|
/* Does namelen bytes of name exactly match the symbol? */
|
|
|
|
static bool sym_is(const char *name, unsigned namelen, const char *symbol)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2012-01-13 07:02:15 +08:00
|
|
|
if (namelen != strlen(symbol))
|
|
|
|
return false;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-01-13 07:02:15 +08:00
|
|
|
return memcmp(name, symbol, namelen) == 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void do_table(void *symval, unsigned long size,
|
|
|
|
unsigned long id_size,
|
2006-07-09 22:26:07 +08:00
|
|
|
const char *device_id,
|
2005-04-17 06:20:36 +08: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 17:15:46 +08:00
|
|
|
device_id_check(mod->name, device_id, size, id_size, symval);
|
2005-04-17 06:20:36 +08: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 17:15:46 +08:00
|
|
|
char *zeros = NULL;
|
2014-02-03 08:44:13 +08:00
|
|
|
const char *name, *identifier;
|
2012-01-13 07:02:15 +08:00
|
|
|
unsigned int namelen;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* We're looking for a section relative symbol */
|
2010-07-29 07:47:53 +08:00
|
|
|
if (!sym->st_shndx || get_secindex(info, sym) >= info->num_sections)
|
2005-04-17 06:20:36 +08:00
|
|
|
return;
|
|
|
|
|
2012-04-13 02:37:30 +08:00
|
|
|
/* We're looking for an object */
|
|
|
|
if (ELF_ST_TYPE(sym->st_info) != STT_OBJECT)
|
|
|
|
return;
|
|
|
|
|
2014-02-03 08:44:13 +08:00
|
|
|
/* All our symbols are of form <prefix>__mod_<name>__<identifier>_device_table. */
|
2012-01-13 07:02:15 +08:00
|
|
|
name = strstr(symname, "__mod_");
|
|
|
|
if (!name)
|
|
|
|
return;
|
|
|
|
name += strlen("__mod_");
|
|
|
|
namelen = strlen(name);
|
|
|
|
if (namelen < strlen("_device_table"))
|
|
|
|
return;
|
|
|
|
if (strcmp(name + namelen - strlen("_device_table"), "_device_table"))
|
|
|
|
return;
|
2014-02-03 08:44:13 +08:00
|
|
|
identifier = strstr(name, "__");
|
|
|
|
if (!identifier)
|
|
|
|
return;
|
|
|
|
namelen = identifier - name;
|
2012-01-13 07:02:15 +08:00
|
|
|
|
2007-09-16 17:15:46 +08:00
|
|
|
/* Handle all-NULL symbols allocated into .bss */
|
2010-07-29 07:47:53 +08:00
|
|
|
if (info->sechdrs[get_secindex(info, sym)].sh_type & SHT_NOBITS) {
|
2007-09-16 17:15:46 +08:00
|
|
|
zeros = calloc(1, sym->st_size);
|
|
|
|
symval = zeros;
|
|
|
|
} else {
|
|
|
|
symval = (void *)info->hdr
|
2010-07-29 07:47:53 +08:00
|
|
|
+ info->sechdrs[get_secindex(info, sym)].sh_offset
|
2007-09-16 17:15:46 +08:00
|
|
|
+ sym->st_value;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-01-13 07:02:15 +08:00
|
|
|
/* First handle the "special" cases */
|
|
|
|
if (sym_is(name, namelen, "usb"))
|
2005-04-23 06:07:01 +08:00
|
|
|
do_usb_table(symval, sym->st_size, mod);
|
modpost: fix module autoloading for OF devices with generic compatible property
Since the wildcard at the end of OF module aliases is gone, autoloading
of modules that don't match a device's last (most generic) compatible
value fails.
For example the CODA960 VPU on i.MX6Q has the SoC specific compatible
"fsl,imx6q-vpu" and the generic compatible "cnm,coda960". Since the
driver currently only works with knowledge about the SoC specific
integration, it doesn't list "cnm,cod960" in the module device table.
This results in the device compatible
"of:NvpuT<NULL>Cfsl,imx6q-vpuCcnm,coda960" not matching the module alias
"of:N*T*Cfsl,imx6q-vpu" anymore, whereas before commit 2f632369ab79
("modpost: don't add a trailing wildcard for OF module aliases") it
matched the module alias "of:N*T*Cfsl,imx6q-vpu*".
This patch adds two module aliases for each compatible, one without the
wildcard and one with "C*" appended.
$ modinfo coda | grep imx6q
alias: of:N*T*Cfsl,imx6q-vpuC*
alias: of:N*T*Cfsl,imx6q-vpu
Fixes: 2f632369ab79 ("modpost: don't add a trailing wildcard for OF module aliases")
Link: http://lkml.kernel.org/r/1462203339-15340-1-git-send-email-p.zabel@pengutronix.de
Signed-off-by: Philipp Zabel <p.zabel@pengutronix.de>
Cc: Javier Martinez Canillas <javier@osg.samsung.com>
Cc: Brian Norris <computersforpeace@gmail.com>
Cc: Sjoerd Simons <sjoerd.simons@collabora.co.uk>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: <stable@vger.kernel.org> [4.5+]
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-05-06 07:22:29 +08:00
|
|
|
if (sym_is(name, namelen, "of"))
|
|
|
|
do_of_table(symval, sym->st_size, mod);
|
2012-01-13 07:02:15 +08:00
|
|
|
else if (sym_is(name, namelen, "pnp"))
|
2008-05-29 05:06:47 +08:00
|
|
|
do_pnp_device_entry(symval, sym->st_size, mod);
|
2012-01-13 07:02:15 +08:00
|
|
|
else if (sym_is(name, namelen, "pnp_card"))
|
2008-02-21 07:35:54 +08:00
|
|
|
do_pnp_card_entries(symval, sym->st_size, mod);
|
2012-01-13 07:02:15 +08:00
|
|
|
else {
|
2012-01-13 07:02:16 +08:00
|
|
|
struct devtable **p;
|
2012-02-24 15:23:53 +08:00
|
|
|
INIT_SECTION(__devtable);
|
2012-01-13 07:02:15 +08:00
|
|
|
|
2012-01-13 07:02:16 +08:00
|
|
|
for (p = __start___devtable; p < __stop___devtable; p++) {
|
|
|
|
if (sym_is(name, namelen, (*p)->device_id)) {
|
|
|
|
do_table(symval, sym->st_size, (*p)->id_size,
|
|
|
|
(*p)->device_id, (*p)->function, mod);
|
2012-01-13 07:02:15 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2007-09-16 17:15:46 +08:00
|
|
|
free(zeros);
|
2005-04-17 06:20:36 +08: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);
|
|
|
|
}
|