Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* Simple code to turn various tables in an ELF file into alias definitions. |
| 2 | * This deals with kernel datastructures where they should be |
| 3 | * dealt with: in the kernel source. |
| 4 | * |
| 5 | * Copyright 2002-2003 Rusty Russell, IBM Corporation |
| 6 | * 2003 Kai Germaschewski |
| 7 | * |
| 8 | * |
| 9 | * This software may be used and distributed according to the terms |
| 10 | * of the GNU General Public License, incorporated herein by reference. |
| 11 | */ |
| 12 | |
| 13 | #include "modpost.h" |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 14 | #include "devicetable-offsets.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | |
| 16 | /* We use the ELF typedefs for kernel_ulong_t but bite the bullet and |
| 17 | * use either stdint.h or inttypes.h for the rest. */ |
| 18 | #if KERNEL_ELFCLASS == ELFCLASS32 |
| 19 | typedef Elf32_Addr kernel_ulong_t; |
Rusty Russell | 1d8f430 | 2005-12-07 21:40:34 +0100 | [diff] [blame] | 20 | #define BITS_PER_LONG 32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 21 | #else |
| 22 | typedef Elf64_Addr kernel_ulong_t; |
Rusty Russell | 1d8f430 | 2005-12-07 21:40:34 +0100 | [diff] [blame] | 23 | #define BITS_PER_LONG 64 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 24 | #endif |
| 25 | #ifdef __sun__ |
| 26 | #include <inttypes.h> |
| 27 | #else |
| 28 | #include <stdint.h> |
| 29 | #endif |
| 30 | |
Jeff Mahoney | 5e65577 | 2005-07-06 15:44:41 -0400 | [diff] [blame] | 31 | #include <ctype.h> |
Rusty Russell | 626596e | 2012-01-13 09:32:15 +1030 | [diff] [blame] | 32 | #include <stdbool.h> |
Jeff Mahoney | 5e65577 | 2005-07-06 15:44:41 -0400 | [diff] [blame] | 33 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 34 | typedef uint32_t __u32; |
| 35 | typedef uint16_t __u16; |
| 36 | typedef unsigned char __u8; |
Greg Kroah-Hartman | b144ce2 | 2015-05-27 17:17:27 -0700 | [diff] [blame] | 37 | typedef struct { |
| 38 | __u8 b[16]; |
| 39 | } uuid_le; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 40 | |
| 41 | /* Big exception to the "don't include kernel headers into userspace, which |
Sam Ravnborg | 62070fa | 2006-03-03 16:46:04 +0100 | [diff] [blame] | 42 | * even potentially has different endianness and word sizes, since |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 43 | * we handle those differences explicitly below */ |
| 44 | #include "../../include/linux/mod_devicetable.h" |
| 45 | |
Rusty Russell | e49ce14 | 2012-01-13 09:32:16 +1030 | [diff] [blame] | 46 | /* This array collects all instances that use the generic do_table */ |
| 47 | struct devtable { |
Tom Gundersen | 21bdd17 | 2014-02-03 11:14:13 +1030 | [diff] [blame] | 48 | const char *device_id; /* name of table, __mod_<name>__*_device_table. */ |
Rusty Russell | e49ce14 | 2012-01-13 09:32:16 +1030 | [diff] [blame] | 49 | unsigned long id_size; |
| 50 | void *function; |
| 51 | }; |
| 52 | |
Andreas Bießmann | dd2a3ac | 2012-02-24 08:23:53 +0100 | [diff] [blame] | 53 | #define ___cat(a,b) a ## b |
| 54 | #define __cat(a,b) ___cat(a,b) |
| 55 | |
| 56 | /* we need some special handling for this host tool running eventually on |
| 57 | * Darwin. The Mach-O section handling is a bit different than ELF section |
| 58 | * handling. The differnces in detail are: |
| 59 | * a) we have segments which have sections |
| 60 | * b) we need a API call to get the respective section symbols */ |
| 61 | #if defined(__MACH__) |
| 62 | #include <mach-o/getsect.h> |
| 63 | |
| 64 | #define INIT_SECTION(name) do { \ |
| 65 | unsigned long name ## _len; \ |
| 66 | char *__cat(pstart_,name) = getsectdata("__TEXT", \ |
| 67 | #name, &__cat(name,_len)); \ |
| 68 | char *__cat(pstop_,name) = __cat(pstart_,name) + \ |
| 69 | __cat(name, _len); \ |
| 70 | __cat(__start_,name) = (void *)__cat(pstart_,name); \ |
| 71 | __cat(__stop_,name) = (void *)__cat(pstop_,name); \ |
| 72 | } while (0) |
| 73 | #define SECTION(name) __attribute__((section("__TEXT, " #name))) |
| 74 | |
| 75 | struct devtable **__start___devtable, **__stop___devtable; |
| 76 | #else |
| 77 | #define INIT_SECTION(name) /* no-op for ELF */ |
| 78 | #define SECTION(name) __attribute__((section(#name))) |
| 79 | |
Rusty Russell | e49ce14 | 2012-01-13 09:32:16 +1030 | [diff] [blame] | 80 | /* We construct a table of pointers in an ELF section (pointers generally |
| 81 | * go unpadded by gcc). ld creates boundary syms for us. */ |
| 82 | extern struct devtable *__start___devtable[], *__stop___devtable[]; |
Andreas Bießmann | dd2a3ac | 2012-02-24 08:23:53 +0100 | [diff] [blame] | 83 | #endif /* __MACH__ */ |
Rusty Russell | e49ce14 | 2012-01-13 09:32:16 +1030 | [diff] [blame] | 84 | |
Daniel Tang | 04130cc | 2013-06-09 12:33:55 +1000 | [diff] [blame] | 85 | #if !defined(__used) |
| 86 | # if __GNUC__ == 3 && __GNUC_MINOR__ < 3 |
| 87 | # define __used __attribute__((__unused__)) |
| 88 | # else |
| 89 | # define __used __attribute__((__used__)) |
| 90 | # endif |
Rusty Russell | e49ce14 | 2012-01-13 09:32:16 +1030 | [diff] [blame] | 91 | #endif |
| 92 | |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 93 | /* Define a variable f that holds the value of field f of struct devid |
| 94 | * based at address m. |
| 95 | */ |
| 96 | #define DEF_FIELD(m, devid, f) \ |
| 97 | typeof(((struct devid *)0)->f) f = TO_NATIVE(*(typeof(f) *)((m) + OFF_##devid##_##f)) |
| 98 | /* Define a variable f that holds the address of field f of struct devid |
| 99 | * based at address m. Due to the way typeof works, for a field of type |
| 100 | * T[N] the variable has type T(*)[N], _not_ T*. |
| 101 | */ |
| 102 | #define DEF_FIELD_ADDR(m, devid, f) \ |
| 103 | typeof(((struct devid *)0)->f) *f = ((m) + OFF_##devid##_##f) |
| 104 | |
Rusty Russell | e49ce14 | 2012-01-13 09:32:16 +1030 | [diff] [blame] | 105 | /* Add a table entry. We test function type matches while we're here. */ |
| 106 | #define ADD_TO_DEVTABLE(device_id, type, function) \ |
| 107 | static struct devtable __cat(devtable,__LINE__) = { \ |
| 108 | device_id + 0*sizeof((function)((const char *)NULL, \ |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 109 | (void *)NULL, \ |
Rusty Russell | e49ce14 | 2012-01-13 09:32:16 +1030 | [diff] [blame] | 110 | (char *)NULL)), \ |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 111 | SIZE_##type, (function) }; \ |
Andreas Bießmann | dd2a3ac | 2012-02-24 08:23:53 +0100 | [diff] [blame] | 112 | static struct devtable *SECTION(__devtable) __used \ |
| 113 | __cat(devtable_ptr,__LINE__) = &__cat(devtable,__LINE__) |
Rusty Russell | e49ce14 | 2012-01-13 09:32:16 +1030 | [diff] [blame] | 114 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 115 | #define ADD(str, sep, cond, field) \ |
| 116 | do { \ |
| 117 | strcat(str, sep); \ |
| 118 | if (cond) \ |
| 119 | sprintf(str + strlen(str), \ |
| 120 | sizeof(field) == 1 ? "%02X" : \ |
| 121 | sizeof(field) == 2 ? "%04X" : \ |
| 122 | sizeof(field) == 4 ? "%08X" : "", \ |
| 123 | field); \ |
| 124 | else \ |
| 125 | sprintf(str + strlen(str), "*"); \ |
| 126 | } while(0) |
| 127 | |
Javier Martinez Canillas | 2f63236 | 2016-01-14 15:17:02 -0800 | [diff] [blame] | 128 | /* End in a wildcard, for future extension */ |
Jean Delvare | ac55182 | 2008-05-02 20:37:21 +0200 | [diff] [blame] | 129 | static inline void add_wildcard(char *str) |
| 130 | { |
| 131 | int len = strlen(str); |
| 132 | |
| 133 | if (str[len - 1] != '*') |
| 134 | strcat(str + len, "*"); |
| 135 | } |
| 136 | |
Greg Kroah-Hartman | b144ce2 | 2015-05-27 17:17:27 -0700 | [diff] [blame] | 137 | static inline void add_uuid(char *str, uuid_le uuid) |
Tomas Winkler | c93b76b | 2015-05-07 15:54:02 +0300 | [diff] [blame] | 138 | { |
| 139 | int len = strlen(str); |
Tomas Winkler | c93b76b | 2015-05-07 15:54:02 +0300 | [diff] [blame] | 140 | |
Prarit Bhargava | 59796ed | 2015-09-10 10:17:59 +0300 | [diff] [blame] | 141 | sprintf(str + len, "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x", |
| 142 | uuid.b[3], uuid.b[2], uuid.b[1], uuid.b[0], |
| 143 | uuid.b[5], uuid.b[4], uuid.b[7], uuid.b[6], |
| 144 | uuid.b[8], uuid.b[9], uuid.b[10], uuid.b[11], |
| 145 | uuid.b[12], uuid.b[13], uuid.b[14], uuid.b[15]); |
Tomas Winkler | c93b76b | 2015-05-07 15:54:02 +0300 | [diff] [blame] | 146 | } |
| 147 | |
Sam Ravnborg | fb33d81 | 2006-07-09 16:26:07 +0200 | [diff] [blame] | 148 | /** |
| 149 | * Check that sizeof(device_id type) are consistent with size of section |
| 150 | * in .o file. If in-consistent then userspace and kernel does not agree |
| 151 | * on actual size which is a bug. |
Kees Cook | e004982 | 2007-09-16 11:15:46 +0200 | [diff] [blame] | 152 | * Also verify that the final entry in the table is all zeros. |
Sam Ravnborg | 4ce6efe | 2008-03-23 21:38:54 +0100 | [diff] [blame] | 153 | * Ignore both checks if build host differ from target host and size differs. |
Sam Ravnborg | fb33d81 | 2006-07-09 16:26:07 +0200 | [diff] [blame] | 154 | **/ |
Kees Cook | e004982 | 2007-09-16 11:15:46 +0200 | [diff] [blame] | 155 | static void device_id_check(const char *modname, const char *device_id, |
| 156 | unsigned long size, unsigned long id_size, |
| 157 | void *symval) |
Sam Ravnborg | fb33d81 | 2006-07-09 16:26:07 +0200 | [diff] [blame] | 158 | { |
Kees Cook | e004982 | 2007-09-16 11:15:46 +0200 | [diff] [blame] | 159 | int i; |
| 160 | |
Sam Ravnborg | fb33d81 | 2006-07-09 16:26:07 +0200 | [diff] [blame] | 161 | if (size % id_size || size < id_size) { |
| 162 | fatal("%s: sizeof(struct %s_device_id)=%lu is not a modulo " |
Tom Gundersen | 21bdd17 | 2014-02-03 11:14:13 +1030 | [diff] [blame] | 163 | "of the size of " |
| 164 | "section __mod_%s__<identifier>_device_table=%lu.\n" |
Sam Ravnborg | fb33d81 | 2006-07-09 16:26:07 +0200 | [diff] [blame] | 165 | "Fix definition of struct %s_device_id " |
| 166 | "in mod_devicetable.h\n", |
| 167 | modname, device_id, id_size, device_id, size, device_id); |
| 168 | } |
Kees Cook | e004982 | 2007-09-16 11:15:46 +0200 | [diff] [blame] | 169 | /* Verify last one is a terminator */ |
| 170 | for (i = 0; i < id_size; i++ ) { |
| 171 | if (*(uint8_t*)(symval+size-id_size+i)) { |
| 172 | fprintf(stderr,"%s: struct %s_device_id is %lu bytes. " |
| 173 | "The last of %lu is:\n", |
| 174 | modname, device_id, id_size, size / id_size); |
| 175 | for (i = 0; i < id_size; i++ ) |
| 176 | fprintf(stderr,"0x%02x ", |
| 177 | *(uint8_t*)(symval+size-id_size+i) ); |
| 178 | fprintf(stderr,"\n"); |
| 179 | fatal("%s: struct %s_device_id is not terminated " |
| 180 | "with a NULL entry!\n", modname, device_id); |
| 181 | } |
| 182 | } |
Sam Ravnborg | fb33d81 | 2006-07-09 16:26:07 +0200 | [diff] [blame] | 183 | } |
| 184 | |
Roman Kagan | b19dcd9 | 2005-04-22 15:07:01 -0700 | [diff] [blame] | 185 | /* USB is special because the bcdDevice can be matched against a numeric range */ |
Bjørn Mork | 81df2d5 | 2012-05-18 21:27:43 +0200 | [diff] [blame] | 186 | /* Looks like "usb:vNpNdNdcNdscNdpNicNiscNipNinN" */ |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 187 | static void do_usb_entry(void *symval, |
Roman Kagan | b19dcd9 | 2005-04-22 15:07:01 -0700 | [diff] [blame] | 188 | unsigned int bcdDevice_initial, int bcdDevice_initial_digits, |
| 189 | unsigned char range_lo, unsigned char range_hi, |
Nathaniel McCallum | afe2dab | 2009-11-18 20:11:23 -0500 | [diff] [blame] | 190 | unsigned char max, struct module *mod) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 191 | { |
Roman Kagan | b19dcd9 | 2005-04-22 15:07:01 -0700 | [diff] [blame] | 192 | char alias[500]; |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 193 | DEF_FIELD(symval, usb_device_id, match_flags); |
| 194 | DEF_FIELD(symval, usb_device_id, idVendor); |
| 195 | DEF_FIELD(symval, usb_device_id, idProduct); |
| 196 | DEF_FIELD(symval, usb_device_id, bcdDevice_lo); |
| 197 | DEF_FIELD(symval, usb_device_id, bDeviceClass); |
| 198 | DEF_FIELD(symval, usb_device_id, bDeviceSubClass); |
| 199 | DEF_FIELD(symval, usb_device_id, bDeviceProtocol); |
| 200 | DEF_FIELD(symval, usb_device_id, bInterfaceClass); |
| 201 | DEF_FIELD(symval, usb_device_id, bInterfaceSubClass); |
| 202 | DEF_FIELD(symval, usb_device_id, bInterfaceProtocol); |
| 203 | DEF_FIELD(symval, usb_device_id, bInterfaceNumber); |
| 204 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 205 | strcpy(alias, "usb:"); |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 206 | ADD(alias, "v", match_flags&USB_DEVICE_ID_MATCH_VENDOR, |
| 207 | idVendor); |
| 208 | ADD(alias, "p", match_flags&USB_DEVICE_ID_MATCH_PRODUCT, |
| 209 | idProduct); |
Roman Kagan | b19dcd9 | 2005-04-22 15:07:01 -0700 | [diff] [blame] | 210 | |
| 211 | strcat(alias, "d"); |
| 212 | if (bcdDevice_initial_digits) |
| 213 | sprintf(alias + strlen(alias), "%0*X", |
| 214 | bcdDevice_initial_digits, bcdDevice_initial); |
| 215 | if (range_lo == range_hi) |
Nathaniel McCallum | afe2dab | 2009-11-18 20:11:23 -0500 | [diff] [blame] | 216 | sprintf(alias + strlen(alias), "%X", range_lo); |
| 217 | else if (range_lo > 0 || range_hi < max) { |
| 218 | if (range_lo > 0x9 || range_hi < 0xA) |
| 219 | sprintf(alias + strlen(alias), |
| 220 | "[%X-%X]", |
| 221 | range_lo, |
| 222 | range_hi); |
| 223 | else { |
| 224 | sprintf(alias + strlen(alias), |
| 225 | range_lo < 0x9 ? "[%X-9" : "[%X", |
| 226 | range_lo); |
| 227 | sprintf(alias + strlen(alias), |
Jan Moskyto Matejka | 03b5632 | 2014-02-07 19:15:11 +0100 | [diff] [blame] | 228 | range_hi > 0xA ? "A-%X]" : "%X]", |
| 229 | range_hi); |
Nathaniel McCallum | afe2dab | 2009-11-18 20:11:23 -0500 | [diff] [blame] | 230 | } |
| 231 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 232 | if (bcdDevice_initial_digits < (sizeof(bcdDevice_lo) * 2 - 1)) |
Roman Kagan | b19dcd9 | 2005-04-22 15:07:01 -0700 | [diff] [blame] | 233 | strcat(alias, "*"); |
| 234 | |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 235 | ADD(alias, "dc", match_flags&USB_DEVICE_ID_MATCH_DEV_CLASS, |
| 236 | bDeviceClass); |
| 237 | ADD(alias, "dsc", match_flags&USB_DEVICE_ID_MATCH_DEV_SUBCLASS, |
| 238 | bDeviceSubClass); |
| 239 | ADD(alias, "dp", match_flags&USB_DEVICE_ID_MATCH_DEV_PROTOCOL, |
| 240 | bDeviceProtocol); |
| 241 | ADD(alias, "ic", match_flags&USB_DEVICE_ID_MATCH_INT_CLASS, |
| 242 | bInterfaceClass); |
| 243 | ADD(alias, "isc", match_flags&USB_DEVICE_ID_MATCH_INT_SUBCLASS, |
| 244 | bInterfaceSubClass); |
| 245 | ADD(alias, "ip", match_flags&USB_DEVICE_ID_MATCH_INT_PROTOCOL, |
| 246 | bInterfaceProtocol); |
| 247 | ADD(alias, "in", match_flags&USB_DEVICE_ID_MATCH_INT_NUMBER, |
| 248 | bInterfaceNumber); |
Roman Kagan | b19dcd9 | 2005-04-22 15:07:01 -0700 | [diff] [blame] | 249 | |
Jean Delvare | ac55182 | 2008-05-02 20:37:21 +0200 | [diff] [blame] | 250 | add_wildcard(alias); |
Roman Kagan | b19dcd9 | 2005-04-22 15:07:01 -0700 | [diff] [blame] | 251 | buf_printf(&mod->dev_table_buf, |
| 252 | "MODULE_ALIAS(\"%s\");\n", alias); |
| 253 | } |
| 254 | |
Nathaniel McCallum | 55f49f2 | 2009-11-18 20:15:28 -0500 | [diff] [blame] | 255 | /* Handles increment/decrement of BCD formatted integers */ |
| 256 | /* Returns the previous value, so it works like i++ or i-- */ |
| 257 | static unsigned int incbcd(unsigned int *bcd, |
| 258 | int inc, |
| 259 | unsigned char max, |
| 260 | size_t chars) |
| 261 | { |
| 262 | unsigned int init = *bcd, i, j; |
| 263 | unsigned long long c, dec = 0; |
| 264 | |
| 265 | /* If bcd is not in BCD format, just increment */ |
| 266 | if (max > 0x9) { |
| 267 | *bcd += inc; |
| 268 | return init; |
| 269 | } |
| 270 | |
| 271 | /* Convert BCD to Decimal */ |
| 272 | for (i=0 ; i < chars ; i++) { |
| 273 | c = (*bcd >> (i << 2)) & 0xf; |
| 274 | c = c > 9 ? 9 : c; /* force to bcd just in case */ |
| 275 | for (j=0 ; j < i ; j++) |
| 276 | c = c * 10; |
| 277 | dec += c; |
| 278 | } |
| 279 | |
| 280 | /* Do our increment/decrement */ |
| 281 | dec += inc; |
| 282 | *bcd = 0; |
| 283 | |
| 284 | /* Convert back to BCD */ |
| 285 | for (i=0 ; i < chars ; i++) { |
| 286 | for (c=1,j=0 ; j < i ; j++) |
| 287 | c = c * 10; |
| 288 | c = (dec / c) % 10; |
| 289 | *bcd += c << (i << 2); |
| 290 | } |
| 291 | return init; |
| 292 | } |
| 293 | |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 294 | static void do_usb_entry_multi(void *symval, struct module *mod) |
Roman Kagan | b19dcd9 | 2005-04-22 15:07:01 -0700 | [diff] [blame] | 295 | { |
| 296 | unsigned int devlo, devhi; |
Nathaniel McCallum | afe2dab | 2009-11-18 20:11:23 -0500 | [diff] [blame] | 297 | unsigned char chi, clo, max; |
Roman Kagan | b19dcd9 | 2005-04-22 15:07:01 -0700 | [diff] [blame] | 298 | int ndigits; |
| 299 | |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 300 | DEF_FIELD(symval, usb_device_id, match_flags); |
| 301 | DEF_FIELD(symval, usb_device_id, idVendor); |
| 302 | DEF_FIELD(symval, usb_device_id, idProduct); |
| 303 | DEF_FIELD(symval, usb_device_id, bcdDevice_lo); |
| 304 | DEF_FIELD(symval, usb_device_id, bcdDevice_hi); |
| 305 | DEF_FIELD(symval, usb_device_id, bDeviceClass); |
| 306 | DEF_FIELD(symval, usb_device_id, bInterfaceClass); |
Roman Kagan | b19dcd9 | 2005-04-22 15:07:01 -0700 | [diff] [blame] | 307 | |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 308 | devlo = match_flags & USB_DEVICE_ID_MATCH_DEV_LO ? |
| 309 | bcdDevice_lo : 0x0U; |
| 310 | devhi = match_flags & USB_DEVICE_ID_MATCH_DEV_HI ? |
| 311 | bcdDevice_hi : ~0x0U; |
Roman Kagan | b19dcd9 | 2005-04-22 15:07:01 -0700 | [diff] [blame] | 312 | |
Nathaniel McCallum | afe2dab | 2009-11-18 20:11:23 -0500 | [diff] [blame] | 313 | /* Figure out if this entry is in bcd or hex format */ |
| 314 | max = 0x9; /* Default to decimal format */ |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 315 | for (ndigits = 0 ; ndigits < sizeof(bcdDevice_lo) * 2 ; ndigits++) { |
Nathaniel McCallum | afe2dab | 2009-11-18 20:11:23 -0500 | [diff] [blame] | 316 | clo = (devlo >> (ndigits << 2)) & 0xf; |
| 317 | chi = ((devhi > 0x9999 ? 0x9999 : devhi) >> (ndigits << 2)) & 0xf; |
| 318 | if (clo > max || chi > max) { |
| 319 | max = 0xf; |
| 320 | break; |
| 321 | } |
| 322 | } |
| 323 | |
Roman Kagan | b19dcd9 | 2005-04-22 15:07:01 -0700 | [diff] [blame] | 324 | /* |
| 325 | * Some modules (visor) have empty slots as placeholder for |
| 326 | * run-time specification that results in catch-all alias |
| 327 | */ |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 328 | if (!(idVendor | idProduct | bDeviceClass | bInterfaceClass)) |
Roman Kagan | b19dcd9 | 2005-04-22 15:07:01 -0700 | [diff] [blame] | 329 | return; |
| 330 | |
| 331 | /* Convert numeric bcdDevice range into fnmatch-able pattern(s) */ |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 332 | for (ndigits = sizeof(bcdDevice_lo) * 2 - 1; devlo <= devhi; ndigits--) { |
Roman Kagan | b19dcd9 | 2005-04-22 15:07:01 -0700 | [diff] [blame] | 333 | clo = devlo & 0xf; |
| 334 | chi = devhi & 0xf; |
Nathaniel McCallum | afe2dab | 2009-11-18 20:11:23 -0500 | [diff] [blame] | 335 | if (chi > max) /* If we are in bcd mode, truncate if necessary */ |
| 336 | chi = max; |
Roman Kagan | b19dcd9 | 2005-04-22 15:07:01 -0700 | [diff] [blame] | 337 | devlo >>= 4; |
| 338 | devhi >>= 4; |
| 339 | |
| 340 | if (devlo == devhi || !ndigits) { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 341 | do_usb_entry(symval, devlo, ndigits, clo, chi, max, mod); |
Roman Kagan | b19dcd9 | 2005-04-22 15:07:01 -0700 | [diff] [blame] | 342 | break; |
| 343 | } |
| 344 | |
Nathaniel McCallum | afe2dab | 2009-11-18 20:11:23 -0500 | [diff] [blame] | 345 | if (clo > 0x0) |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 346 | do_usb_entry(symval, |
Nathaniel McCallum | 55f49f2 | 2009-11-18 20:15:28 -0500 | [diff] [blame] | 347 | incbcd(&devlo, 1, max, |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 348 | sizeof(bcdDevice_lo) * 2), |
Nathaniel McCallum | 55f49f2 | 2009-11-18 20:15:28 -0500 | [diff] [blame] | 349 | ndigits, clo, max, max, mod); |
Roman Kagan | b19dcd9 | 2005-04-22 15:07:01 -0700 | [diff] [blame] | 350 | |
Nathaniel McCallum | afe2dab | 2009-11-18 20:11:23 -0500 | [diff] [blame] | 351 | if (chi < max) |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 352 | do_usb_entry(symval, |
Nathaniel McCallum | 55f49f2 | 2009-11-18 20:15:28 -0500 | [diff] [blame] | 353 | incbcd(&devhi, -1, max, |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 354 | sizeof(bcdDevice_lo) * 2), |
Nathaniel McCallum | 55f49f2 | 2009-11-18 20:15:28 -0500 | [diff] [blame] | 355 | ndigits, 0x0, chi, max, mod); |
Roman Kagan | b19dcd9 | 2005-04-22 15:07:01 -0700 | [diff] [blame] | 356 | } |
| 357 | } |
| 358 | |
| 359 | static void do_usb_table(void *symval, unsigned long size, |
| 360 | struct module *mod) |
| 361 | { |
| 362 | unsigned int i; |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 363 | const unsigned long id_size = SIZE_usb_device_id; |
Roman Kagan | b19dcd9 | 2005-04-22 15:07:01 -0700 | [diff] [blame] | 364 | |
Kees Cook | e004982 | 2007-09-16 11:15:46 +0200 | [diff] [blame] | 365 | device_id_check(mod->name, "usb", size, id_size, symval); |
Sam Ravnborg | fb33d81 | 2006-07-09 16:26:07 +0200 | [diff] [blame] | 366 | |
Roman Kagan | b19dcd9 | 2005-04-22 15:07:01 -0700 | [diff] [blame] | 367 | /* Leave last one: it's the terminator. */ |
| 368 | size -= id_size; |
| 369 | |
| 370 | for (i = 0; i < size; i += id_size) |
| 371 | do_usb_entry_multi(symval + i, mod); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 372 | } |
| 373 | |
Philipp Zabel | acbef7b | 2016-05-05 16:22:29 -0700 | [diff] [blame] | 374 | static void do_of_entry_multi(void *symval, struct module *mod) |
| 375 | { |
| 376 | char alias[500]; |
| 377 | int len; |
| 378 | char *tmp; |
| 379 | |
| 380 | DEF_FIELD_ADDR(symval, of_device_id, name); |
| 381 | DEF_FIELD_ADDR(symval, of_device_id, type); |
| 382 | DEF_FIELD_ADDR(symval, of_device_id, compatible); |
| 383 | |
| 384 | len = sprintf(alias, "of:N%sT%s", (*name)[0] ? *name : "*", |
| 385 | (*type)[0] ? *type : "*"); |
| 386 | |
Wolfram Sang | b3c0a4d | 2016-06-06 18:48:38 +0200 | [diff] [blame] | 387 | if ((*compatible)[0]) |
Philipp Zabel | acbef7b | 2016-05-05 16:22:29 -0700 | [diff] [blame] | 388 | sprintf(&alias[len], "%sC%s", (*type)[0] ? "*" : "", |
| 389 | *compatible); |
| 390 | |
| 391 | /* Replace all whitespace with underscores */ |
| 392 | for (tmp = alias; tmp && *tmp; tmp++) |
| 393 | if (isspace(*tmp)) |
| 394 | *tmp = '_'; |
| 395 | |
| 396 | buf_printf(&mod->dev_table_buf, "MODULE_ALIAS(\"%s\");\n", alias); |
| 397 | strcat(alias, "C"); |
| 398 | add_wildcard(alias); |
| 399 | buf_printf(&mod->dev_table_buf, "MODULE_ALIAS(\"%s\");\n", alias); |
| 400 | } |
| 401 | |
| 402 | static void do_of_table(void *symval, unsigned long size, |
| 403 | struct module *mod) |
| 404 | { |
| 405 | unsigned int i; |
| 406 | const unsigned long id_size = SIZE_of_device_id; |
| 407 | |
| 408 | device_id_check(mod->name, "of", size, id_size, symval); |
| 409 | |
| 410 | /* Leave last one: it's the terminator. */ |
| 411 | size -= id_size; |
| 412 | |
| 413 | for (i = 0; i < size; i += id_size) |
| 414 | do_of_entry_multi(symval + i, mod); |
| 415 | } |
| 416 | |
Jiri Slaby | e8c84f9 | 2008-05-19 15:50:01 +0200 | [diff] [blame] | 417 | /* Looks like: hid:bNvNpN */ |
| 418 | static int do_hid_entry(const char *filename, |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 419 | void *symval, char *alias) |
Jiri Slaby | e8c84f9 | 2008-05-19 15:50:01 +0200 | [diff] [blame] | 420 | { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 421 | DEF_FIELD(symval, hid_device_id, bus); |
| 422 | DEF_FIELD(symval, hid_device_id, group); |
| 423 | DEF_FIELD(symval, hid_device_id, vendor); |
| 424 | DEF_FIELD(symval, hid_device_id, product); |
Jiri Slaby | e8c84f9 | 2008-05-19 15:50:01 +0200 | [diff] [blame] | 425 | |
Henrik Rydberg | 7431fb7 | 2012-04-23 12:07:04 +0200 | [diff] [blame] | 426 | sprintf(alias, "hid:"); |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 427 | ADD(alias, "b", bus != HID_BUS_ANY, bus); |
| 428 | ADD(alias, "g", group != HID_GROUP_ANY, group); |
| 429 | ADD(alias, "v", vendor != HID_ANY_ID, vendor); |
| 430 | ADD(alias, "p", product != HID_ANY_ID, product); |
Jiri Slaby | e8c84f9 | 2008-05-19 15:50:01 +0200 | [diff] [blame] | 431 | |
| 432 | return 1; |
| 433 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 434 | ADD_TO_DEVTABLE("hid", hid_device_id, do_hid_entry); |
Jiri Slaby | e8c84f9 | 2008-05-19 15:50:01 +0200 | [diff] [blame] | 435 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 436 | /* Looks like: ieee1394:venNmoNspNverN */ |
| 437 | static int do_ieee1394_entry(const char *filename, |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 438 | void *symval, char *alias) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 439 | { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 440 | DEF_FIELD(symval, ieee1394_device_id, match_flags); |
| 441 | DEF_FIELD(symval, ieee1394_device_id, vendor_id); |
| 442 | DEF_FIELD(symval, ieee1394_device_id, model_id); |
| 443 | DEF_FIELD(symval, ieee1394_device_id, specifier_id); |
| 444 | DEF_FIELD(symval, ieee1394_device_id, version); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 445 | |
| 446 | strcpy(alias, "ieee1394:"); |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 447 | ADD(alias, "ven", match_flags & IEEE1394_MATCH_VENDOR_ID, |
| 448 | vendor_id); |
| 449 | ADD(alias, "mo", match_flags & IEEE1394_MATCH_MODEL_ID, |
| 450 | model_id); |
| 451 | ADD(alias, "sp", match_flags & IEEE1394_MATCH_SPECIFIER_ID, |
| 452 | specifier_id); |
| 453 | ADD(alias, "ver", match_flags & IEEE1394_MATCH_VERSION, |
| 454 | version); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 455 | |
Jean Delvare | ac55182 | 2008-05-02 20:37:21 +0200 | [diff] [blame] | 456 | add_wildcard(alias); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 457 | return 1; |
| 458 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 459 | ADD_TO_DEVTABLE("ieee1394", ieee1394_device_id, do_ieee1394_entry); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 460 | |
| 461 | /* Looks like: pci:vNdNsvNsdNbcNscNiN. */ |
| 462 | static int do_pci_entry(const char *filename, |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 463 | void *symval, char *alias) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 464 | { |
| 465 | /* Class field can be divided into these three. */ |
| 466 | unsigned char baseclass, subclass, interface, |
| 467 | baseclass_mask, subclass_mask, interface_mask; |
| 468 | |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 469 | DEF_FIELD(symval, pci_device_id, vendor); |
| 470 | DEF_FIELD(symval, pci_device_id, device); |
| 471 | DEF_FIELD(symval, pci_device_id, subvendor); |
| 472 | DEF_FIELD(symval, pci_device_id, subdevice); |
| 473 | DEF_FIELD(symval, pci_device_id, class); |
| 474 | DEF_FIELD(symval, pci_device_id, class_mask); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 475 | |
| 476 | strcpy(alias, "pci:"); |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 477 | ADD(alias, "v", vendor != PCI_ANY_ID, vendor); |
| 478 | ADD(alias, "d", device != PCI_ANY_ID, device); |
| 479 | ADD(alias, "sv", subvendor != PCI_ANY_ID, subvendor); |
| 480 | ADD(alias, "sd", subdevice != PCI_ANY_ID, subdevice); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 481 | |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 482 | baseclass = (class) >> 16; |
| 483 | baseclass_mask = (class_mask) >> 16; |
| 484 | subclass = (class) >> 8; |
| 485 | subclass_mask = (class_mask) >> 8; |
| 486 | interface = class; |
| 487 | interface_mask = class_mask; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 488 | |
| 489 | if ((baseclass_mask != 0 && baseclass_mask != 0xFF) |
| 490 | || (subclass_mask != 0 && subclass_mask != 0xFF) |
| 491 | || (interface_mask != 0 && interface_mask != 0xFF)) { |
Sam Ravnborg | cb80514 | 2006-01-28 16:57:26 +0100 | [diff] [blame] | 492 | warn("Can't handle masks in %s:%04X\n", |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 493 | filename, class_mask); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 494 | return 0; |
| 495 | } |
| 496 | |
| 497 | ADD(alias, "bc", baseclass_mask == 0xFF, baseclass); |
| 498 | ADD(alias, "sc", subclass_mask == 0xFF, subclass); |
| 499 | ADD(alias, "i", interface_mask == 0xFF, interface); |
Jean Delvare | ac55182 | 2008-05-02 20:37:21 +0200 | [diff] [blame] | 500 | add_wildcard(alias); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 501 | return 1; |
| 502 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 503 | ADD_TO_DEVTABLE("pci", pci_device_id, do_pci_entry); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 504 | |
Sam Ravnborg | 62070fa | 2006-03-03 16:46:04 +0100 | [diff] [blame] | 505 | /* looks like: "ccw:tNmNdtNdmN" */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 506 | static int do_ccw_entry(const char *filename, |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 507 | void *symval, char *alias) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 508 | { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 509 | DEF_FIELD(symval, ccw_device_id, match_flags); |
| 510 | DEF_FIELD(symval, ccw_device_id, cu_type); |
| 511 | DEF_FIELD(symval, ccw_device_id, cu_model); |
| 512 | DEF_FIELD(symval, ccw_device_id, dev_type); |
| 513 | DEF_FIELD(symval, ccw_device_id, dev_model); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 514 | |
| 515 | strcpy(alias, "ccw:"); |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 516 | ADD(alias, "t", match_flags&CCW_DEVICE_ID_MATCH_CU_TYPE, |
| 517 | cu_type); |
| 518 | ADD(alias, "m", match_flags&CCW_DEVICE_ID_MATCH_CU_MODEL, |
| 519 | cu_model); |
| 520 | ADD(alias, "dt", match_flags&CCW_DEVICE_ID_MATCH_DEVICE_TYPE, |
| 521 | dev_type); |
| 522 | ADD(alias, "dm", match_flags&CCW_DEVICE_ID_MATCH_DEVICE_MODEL, |
| 523 | dev_model); |
Jean Delvare | ac55182 | 2008-05-02 20:37:21 +0200 | [diff] [blame] | 524 | add_wildcard(alias); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 525 | return 1; |
| 526 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 527 | ADD_TO_DEVTABLE("ccw", ccw_device_id, do_ccw_entry); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 528 | |
Martin Schwidefsky | 1534c38 | 2006-09-20 15:58:25 +0200 | [diff] [blame] | 529 | /* looks like: "ap:tN" */ |
| 530 | static int do_ap_entry(const char *filename, |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 531 | void *symval, char *alias) |
Martin Schwidefsky | 1534c38 | 2006-09-20 15:58:25 +0200 | [diff] [blame] | 532 | { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 533 | DEF_FIELD(symval, ap_device_id, dev_type); |
| 534 | |
| 535 | sprintf(alias, "ap:t%02X*", dev_type); |
Martin Schwidefsky | 1534c38 | 2006-09-20 15:58:25 +0200 | [diff] [blame] | 536 | return 1; |
| 537 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 538 | ADD_TO_DEVTABLE("ap", ap_device_id, do_ap_entry); |
Martin Schwidefsky | 1534c38 | 2006-09-20 15:58:25 +0200 | [diff] [blame] | 539 | |
Cornelia Huck | 7e9db9e | 2008-07-14 09:58:44 +0200 | [diff] [blame] | 540 | /* looks like: "css:tN" */ |
| 541 | static int do_css_entry(const char *filename, |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 542 | void *symval, char *alias) |
Cornelia Huck | 7e9db9e | 2008-07-14 09:58:44 +0200 | [diff] [blame] | 543 | { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 544 | DEF_FIELD(symval, css_device_id, type); |
| 545 | |
| 546 | sprintf(alias, "css:t%01X", type); |
Cornelia Huck | 7e9db9e | 2008-07-14 09:58:44 +0200 | [diff] [blame] | 547 | return 1; |
| 548 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 549 | ADD_TO_DEVTABLE("css", css_device_id, do_css_entry); |
Cornelia Huck | 7e9db9e | 2008-07-14 09:58:44 +0200 | [diff] [blame] | 550 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 551 | /* Looks like: "serio:tyNprNidNexN" */ |
| 552 | static int do_serio_entry(const char *filename, |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 553 | void *symval, char *alias) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 554 | { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 555 | DEF_FIELD(symval, serio_device_id, type); |
| 556 | DEF_FIELD(symval, serio_device_id, proto); |
| 557 | DEF_FIELD(symval, serio_device_id, id); |
| 558 | DEF_FIELD(symval, serio_device_id, extra); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 559 | |
| 560 | strcpy(alias, "serio:"); |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 561 | ADD(alias, "ty", type != SERIO_ANY, type); |
| 562 | ADD(alias, "pr", proto != SERIO_ANY, proto); |
| 563 | ADD(alias, "id", id != SERIO_ANY, id); |
| 564 | ADD(alias, "ex", extra != SERIO_ANY, extra); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 565 | |
Jean Delvare | ac55182 | 2008-05-02 20:37:21 +0200 | [diff] [blame] | 566 | add_wildcard(alias); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 567 | return 1; |
| 568 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 569 | ADD_TO_DEVTABLE("serio", serio_device_id, do_serio_entry); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 570 | |
Suthikulpanit, Suravee | 26095a0 | 2015-07-07 01:55:20 +0200 | [diff] [blame] | 571 | /* looks like: "acpi:ACPI0003" or "acpi:PNP0C0B" or "acpi:LNXVIDEO" or |
| 572 | * "acpi:bbsspp" (bb=base-class, ss=sub-class, pp=prog-if) |
| 573 | * |
| 574 | * NOTE: Each driver should use one of the following : _HID, _CIDs |
| 575 | * or _CLS. Also, bb, ss, and pp can be substituted with ?? |
| 576 | * as don't care byte. |
| 577 | */ |
Thomas Renninger | 29b71a1 | 2007-07-23 14:43:51 +0200 | [diff] [blame] | 578 | static int do_acpi_entry(const char *filename, |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 579 | void *symval, char *alias) |
Thomas Renninger | 29b71a1 | 2007-07-23 14:43:51 +0200 | [diff] [blame] | 580 | { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 581 | DEF_FIELD_ADDR(symval, acpi_device_id, id); |
Suthikulpanit, Suravee | 26095a0 | 2015-07-07 01:55:20 +0200 | [diff] [blame] | 582 | DEF_FIELD_ADDR(symval, acpi_device_id, cls); |
| 583 | DEF_FIELD_ADDR(symval, acpi_device_id, cls_msk); |
| 584 | |
| 585 | if (id && strlen((const char *)*id)) |
| 586 | sprintf(alias, "acpi*:%s:*", *id); |
| 587 | else if (cls) { |
| 588 | int i, byte_shift, cnt = 0; |
| 589 | unsigned int msk; |
| 590 | |
| 591 | sprintf(&alias[cnt], "acpi*:"); |
| 592 | cnt = 6; |
| 593 | for (i = 1; i <= 3; i++) { |
| 594 | byte_shift = 8 * (3-i); |
| 595 | msk = (*cls_msk >> byte_shift) & 0xFF; |
| 596 | if (msk) |
| 597 | sprintf(&alias[cnt], "%02x", |
| 598 | (*cls >> byte_shift) & 0xFF); |
| 599 | else |
| 600 | sprintf(&alias[cnt], "??"); |
| 601 | cnt += 2; |
| 602 | } |
| 603 | sprintf(&alias[cnt], ":*"); |
| 604 | } |
Thomas Renninger | 29b71a1 | 2007-07-23 14:43:51 +0200 | [diff] [blame] | 605 | return 1; |
| 606 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 607 | ADD_TO_DEVTABLE("acpi", acpi_device_id, do_acpi_entry); |
Thomas Renninger | 29b71a1 | 2007-07-23 14:43:51 +0200 | [diff] [blame] | 608 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 609 | /* looks like: "pnp:dD" */ |
Kay Sievers | 22454cb | 2008-05-28 23:06:47 +0200 | [diff] [blame] | 610 | static void do_pnp_device_entry(void *symval, unsigned long size, |
| 611 | struct module *mod) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 612 | { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 613 | const unsigned long id_size = SIZE_pnp_device_id; |
Kay Sievers | 5e4c656 | 2008-08-21 15:28:56 +0200 | [diff] [blame] | 614 | const unsigned int count = (size / id_size)-1; |
Kay Sievers | 5e4c656 | 2008-08-21 15:28:56 +0200 | [diff] [blame] | 615 | unsigned int i; |
Kay Sievers | 22454cb | 2008-05-28 23:06:47 +0200 | [diff] [blame] | 616 | |
| 617 | device_id_check(mod->name, "pnp", size, id_size, symval); |
| 618 | |
Kay Sievers | 5e4c656 | 2008-08-21 15:28:56 +0200 | [diff] [blame] | 619 | for (i = 0; i < count; i++) { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 620 | DEF_FIELD_ADDR(symval + i*id_size, pnp_device_id, id); |
| 621 | char acpi_id[sizeof(*id)]; |
Kay Sievers | 72638f5 | 2009-01-08 03:06:42 +0100 | [diff] [blame] | 622 | int j; |
Kay Sievers | 5e4c656 | 2008-08-21 15:28:56 +0200 | [diff] [blame] | 623 | |
| 624 | buf_printf(&mod->dev_table_buf, |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 625 | "MODULE_ALIAS(\"pnp:d%s*\");\n", *id); |
Kay Sievers | 72638f5 | 2009-01-08 03:06:42 +0100 | [diff] [blame] | 626 | |
| 627 | /* fix broken pnp bus lowercasing */ |
| 628 | for (j = 0; j < sizeof(acpi_id); j++) |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 629 | acpi_id[j] = toupper((*id)[j]); |
Kay Sievers | 5e4c656 | 2008-08-21 15:28:56 +0200 | [diff] [blame] | 630 | buf_printf(&mod->dev_table_buf, |
Kay Sievers | 72638f5 | 2009-01-08 03:06:42 +0100 | [diff] [blame] | 631 | "MODULE_ALIAS(\"acpi*:%s:*\");\n", acpi_id); |
Kay Sievers | 5e4c656 | 2008-08-21 15:28:56 +0200 | [diff] [blame] | 632 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 633 | } |
| 634 | |
Kay Sievers | 0c81eed | 2008-02-21 00:35:54 +0100 | [diff] [blame] | 635 | /* looks like: "pnp:dD" for every device of the card */ |
| 636 | static void do_pnp_card_entries(void *symval, unsigned long size, |
| 637 | struct module *mod) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 638 | { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 639 | const unsigned long id_size = SIZE_pnp_card_device_id; |
Kay Sievers | 0c81eed | 2008-02-21 00:35:54 +0100 | [diff] [blame] | 640 | const unsigned int count = (size / id_size)-1; |
Kay Sievers | 0c81eed | 2008-02-21 00:35:54 +0100 | [diff] [blame] | 641 | unsigned int i; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 642 | |
Kay Sievers | 0c81eed | 2008-02-21 00:35:54 +0100 | [diff] [blame] | 643 | device_id_check(mod->name, "pnp", size, id_size, symval); |
| 644 | |
| 645 | for (i = 0; i < count; i++) { |
| 646 | unsigned int j; |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 647 | DEF_FIELD_ADDR(symval + i*id_size, pnp_card_device_id, devs); |
Kay Sievers | 0c81eed | 2008-02-21 00:35:54 +0100 | [diff] [blame] | 648 | |
| 649 | for (j = 0; j < PNP_MAX_DEVICES; j++) { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 650 | const char *id = (char *)(*devs)[j].id; |
Kay Sievers | 0c81eed | 2008-02-21 00:35:54 +0100 | [diff] [blame] | 651 | int i2, j2; |
| 652 | int dup = 0; |
| 653 | |
| 654 | if (!id[0]) |
| 655 | break; |
| 656 | |
| 657 | /* find duplicate, already added value */ |
| 658 | for (i2 = 0; i2 < i && !dup; i2++) { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 659 | DEF_FIELD_ADDR(symval + i2*id_size, pnp_card_device_id, devs); |
Kay Sievers | 0c81eed | 2008-02-21 00:35:54 +0100 | [diff] [blame] | 660 | |
| 661 | for (j2 = 0; j2 < PNP_MAX_DEVICES; j2++) { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 662 | const char *id2 = (char *)(*devs)[j2].id; |
Kay Sievers | 0c81eed | 2008-02-21 00:35:54 +0100 | [diff] [blame] | 663 | |
| 664 | if (!id2[0]) |
| 665 | break; |
| 666 | |
| 667 | if (!strcmp(id, id2)) { |
| 668 | dup = 1; |
| 669 | break; |
| 670 | } |
| 671 | } |
| 672 | } |
| 673 | |
| 674 | /* add an individual alias for every device entry */ |
Kay Sievers | 22454cb | 2008-05-28 23:06:47 +0200 | [diff] [blame] | 675 | if (!dup) { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 676 | char acpi_id[PNP_ID_LEN]; |
Kay Sievers | 72638f5 | 2009-01-08 03:06:42 +0100 | [diff] [blame] | 677 | int k; |
| 678 | |
Kay Sievers | 0c81eed | 2008-02-21 00:35:54 +0100 | [diff] [blame] | 679 | buf_printf(&mod->dev_table_buf, |
| 680 | "MODULE_ALIAS(\"pnp:d%s*\");\n", id); |
Kay Sievers | 72638f5 | 2009-01-08 03:06:42 +0100 | [diff] [blame] | 681 | |
| 682 | /* fix broken pnp bus lowercasing */ |
| 683 | for (k = 0; k < sizeof(acpi_id); k++) |
| 684 | acpi_id[k] = toupper(id[k]); |
Kay Sievers | 22454cb | 2008-05-28 23:06:47 +0200 | [diff] [blame] | 685 | buf_printf(&mod->dev_table_buf, |
Kay Sievers | 72638f5 | 2009-01-08 03:06:42 +0100 | [diff] [blame] | 686 | "MODULE_ALIAS(\"acpi*:%s:*\");\n", acpi_id); |
Kay Sievers | 22454cb | 2008-05-28 23:06:47 +0200 | [diff] [blame] | 687 | } |
Kay Sievers | 0c81eed | 2008-02-21 00:35:54 +0100 | [diff] [blame] | 688 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 689 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 690 | } |
| 691 | |
Dominik Brodowski | 90829cf | 2005-06-27 16:28:12 -0700 | [diff] [blame] | 692 | /* Looks like: pcmcia:mNcNfNfnNpfnNvaNvbNvcNvdN. */ |
| 693 | static int do_pcmcia_entry(const char *filename, |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 694 | void *symval, char *alias) |
Dominik Brodowski | 90829cf | 2005-06-27 16:28:12 -0700 | [diff] [blame] | 695 | { |
| 696 | unsigned int i; |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 697 | DEF_FIELD(symval, pcmcia_device_id, match_flags); |
| 698 | DEF_FIELD(symval, pcmcia_device_id, manf_id); |
| 699 | DEF_FIELD(symval, pcmcia_device_id, card_id); |
| 700 | DEF_FIELD(symval, pcmcia_device_id, func_id); |
| 701 | DEF_FIELD(symval, pcmcia_device_id, function); |
| 702 | DEF_FIELD(symval, pcmcia_device_id, device_no); |
| 703 | DEF_FIELD_ADDR(symval, pcmcia_device_id, prod_id_hash); |
Kars de Jong | 4fb7edc | 2005-09-25 14:39:46 +0200 | [diff] [blame] | 704 | |
Dominik Brodowski | 90829cf | 2005-06-27 16:28:12 -0700 | [diff] [blame] | 705 | for (i=0; i<4; i++) { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 706 | (*prod_id_hash)[i] = TO_NATIVE((*prod_id_hash)[i]); |
| 707 | } |
Dominik Brodowski | 90829cf | 2005-06-27 16:28:12 -0700 | [diff] [blame] | 708 | |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 709 | strcpy(alias, "pcmcia:"); |
| 710 | ADD(alias, "m", match_flags & PCMCIA_DEV_ID_MATCH_MANF_ID, |
| 711 | manf_id); |
| 712 | ADD(alias, "c", match_flags & PCMCIA_DEV_ID_MATCH_CARD_ID, |
| 713 | card_id); |
| 714 | ADD(alias, "f", match_flags & PCMCIA_DEV_ID_MATCH_FUNC_ID, |
| 715 | func_id); |
| 716 | ADD(alias, "fn", match_flags & PCMCIA_DEV_ID_MATCH_FUNCTION, |
| 717 | function); |
| 718 | ADD(alias, "pfn", match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO, |
| 719 | device_no); |
| 720 | ADD(alias, "pa", match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID1, (*prod_id_hash)[0]); |
| 721 | ADD(alias, "pb", match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID2, (*prod_id_hash)[1]); |
| 722 | ADD(alias, "pc", match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID3, (*prod_id_hash)[2]); |
| 723 | ADD(alias, "pd", match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID4, (*prod_id_hash)[3]); |
Dominik Brodowski | 90829cf | 2005-06-27 16:28:12 -0700 | [diff] [blame] | 724 | |
Jean Delvare | ac55182 | 2008-05-02 20:37:21 +0200 | [diff] [blame] | 725 | add_wildcard(alias); |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 726 | return 1; |
Dominik Brodowski | 90829cf | 2005-06-27 16:28:12 -0700 | [diff] [blame] | 727 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 728 | ADD_TO_DEVTABLE("pcmcia", pcmcia_device_id, do_pcmcia_entry); |
Dominik Brodowski | 90829cf | 2005-06-27 16:28:12 -0700 | [diff] [blame] | 729 | |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 730 | static int do_vio_entry(const char *filename, void *symval, |
Stephen Rothwell | fb120da | 2005-08-17 16:42:59 +1000 | [diff] [blame] | 731 | char *alias) |
| 732 | { |
| 733 | char *tmp; |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 734 | DEF_FIELD_ADDR(symval, vio_device_id, type); |
| 735 | DEF_FIELD_ADDR(symval, vio_device_id, compat); |
Stephen Rothwell | fb120da | 2005-08-17 16:42:59 +1000 | [diff] [blame] | 736 | |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 737 | sprintf(alias, "vio:T%sS%s", (*type)[0] ? *type : "*", |
| 738 | (*compat)[0] ? *compat : "*"); |
Stephen Rothwell | fb120da | 2005-08-17 16:42:59 +1000 | [diff] [blame] | 739 | |
| 740 | /* Replace all whitespace with underscores */ |
| 741 | for (tmp = alias; tmp && *tmp; tmp++) |
| 742 | if (isspace (*tmp)) |
| 743 | *tmp = '_'; |
| 744 | |
Jean Delvare | ac55182 | 2008-05-02 20:37:21 +0200 | [diff] [blame] | 745 | add_wildcard(alias); |
Stephen Rothwell | fb120da | 2005-08-17 16:42:59 +1000 | [diff] [blame] | 746 | return 1; |
| 747 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 748 | ADD_TO_DEVTABLE("vio", vio_device_id, do_vio_entry); |
Stephen Rothwell | fb120da | 2005-08-17 16:42:59 +1000 | [diff] [blame] | 749 | |
Rusty Russell | 1d8f430 | 2005-12-07 21:40:34 +0100 | [diff] [blame] | 750 | #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) |
| 751 | |
| 752 | static void do_input(char *alias, |
| 753 | kernel_ulong_t *arr, unsigned int min, unsigned int max) |
| 754 | { |
| 755 | unsigned int i; |
Dmitry Torokhov | ddc5d34 | 2006-04-26 00:14:19 -0400 | [diff] [blame] | 756 | |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 757 | for (i = min / BITS_PER_LONG; i < max / BITS_PER_LONG + 1; i++) |
| 758 | arr[i] = TO_NATIVE(arr[i]); |
Dmitry Torokhov | ddc5d34 | 2006-04-26 00:14:19 -0400 | [diff] [blame] | 759 | for (i = min; i < max; i++) |
Hans de Goede | e0e9263 | 2006-08-15 12:09:27 +0200 | [diff] [blame] | 760 | if (arr[i / BITS_PER_LONG] & (1L << (i%BITS_PER_LONG))) |
Dmitry Torokhov | ddc5d34 | 2006-04-26 00:14:19 -0400 | [diff] [blame] | 761 | sprintf(alias + strlen(alias), "%X,*", i); |
Rusty Russell | 1d8f430 | 2005-12-07 21:40:34 +0100 | [diff] [blame] | 762 | } |
| 763 | |
| 764 | /* input:b0v0p0e0-eXkXrXaXmXlXsXfXwX where X is comma-separated %02X. */ |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 765 | static int do_input_entry(const char *filename, void *symval, |
Rusty Russell | 1d8f430 | 2005-12-07 21:40:34 +0100 | [diff] [blame] | 766 | char *alias) |
| 767 | { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 768 | DEF_FIELD(symval, input_device_id, flags); |
| 769 | DEF_FIELD(symval, input_device_id, bustype); |
| 770 | DEF_FIELD(symval, input_device_id, vendor); |
| 771 | DEF_FIELD(symval, input_device_id, product); |
| 772 | DEF_FIELD(symval, input_device_id, version); |
| 773 | DEF_FIELD_ADDR(symval, input_device_id, evbit); |
| 774 | DEF_FIELD_ADDR(symval, input_device_id, keybit); |
| 775 | DEF_FIELD_ADDR(symval, input_device_id, relbit); |
| 776 | DEF_FIELD_ADDR(symval, input_device_id, absbit); |
| 777 | DEF_FIELD_ADDR(symval, input_device_id, mscbit); |
| 778 | DEF_FIELD_ADDR(symval, input_device_id, ledbit); |
| 779 | DEF_FIELD_ADDR(symval, input_device_id, sndbit); |
| 780 | DEF_FIELD_ADDR(symval, input_device_id, ffbit); |
| 781 | DEF_FIELD_ADDR(symval, input_device_id, swbit); |
| 782 | |
Rusty Russell | 1d8f430 | 2005-12-07 21:40:34 +0100 | [diff] [blame] | 783 | sprintf(alias, "input:"); |
| 784 | |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 785 | ADD(alias, "b", flags & INPUT_DEVICE_ID_MATCH_BUS, bustype); |
| 786 | ADD(alias, "v", flags & INPUT_DEVICE_ID_MATCH_VENDOR, vendor); |
| 787 | ADD(alias, "p", flags & INPUT_DEVICE_ID_MATCH_PRODUCT, product); |
| 788 | ADD(alias, "e", flags & INPUT_DEVICE_ID_MATCH_VERSION, version); |
Rusty Russell | 1d8f430 | 2005-12-07 21:40:34 +0100 | [diff] [blame] | 789 | |
| 790 | sprintf(alias + strlen(alias), "-e*"); |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 791 | if (flags & INPUT_DEVICE_ID_MATCH_EVBIT) |
| 792 | do_input(alias, *evbit, 0, INPUT_DEVICE_ID_EV_MAX); |
Rusty Russell | 1d8f430 | 2005-12-07 21:40:34 +0100 | [diff] [blame] | 793 | sprintf(alias + strlen(alias), "k*"); |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 794 | if (flags & INPUT_DEVICE_ID_MATCH_KEYBIT) |
| 795 | do_input(alias, *keybit, |
Sam Ravnborg | dc24f0e | 2007-03-09 19:59:06 +0100 | [diff] [blame] | 796 | INPUT_DEVICE_ID_KEY_MIN_INTERESTING, |
| 797 | INPUT_DEVICE_ID_KEY_MAX); |
Rusty Russell | 1d8f430 | 2005-12-07 21:40:34 +0100 | [diff] [blame] | 798 | sprintf(alias + strlen(alias), "r*"); |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 799 | if (flags & INPUT_DEVICE_ID_MATCH_RELBIT) |
| 800 | do_input(alias, *relbit, 0, INPUT_DEVICE_ID_REL_MAX); |
Rusty Russell | 1d8f430 | 2005-12-07 21:40:34 +0100 | [diff] [blame] | 801 | sprintf(alias + strlen(alias), "a*"); |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 802 | if (flags & INPUT_DEVICE_ID_MATCH_ABSBIT) |
| 803 | do_input(alias, *absbit, 0, INPUT_DEVICE_ID_ABS_MAX); |
Rusty Russell | 1d8f430 | 2005-12-07 21:40:34 +0100 | [diff] [blame] | 804 | sprintf(alias + strlen(alias), "m*"); |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 805 | if (flags & INPUT_DEVICE_ID_MATCH_MSCIT) |
| 806 | do_input(alias, *mscbit, 0, INPUT_DEVICE_ID_MSC_MAX); |
Rusty Russell | 1d8f430 | 2005-12-07 21:40:34 +0100 | [diff] [blame] | 807 | sprintf(alias + strlen(alias), "l*"); |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 808 | if (flags & INPUT_DEVICE_ID_MATCH_LEDBIT) |
| 809 | do_input(alias, *ledbit, 0, INPUT_DEVICE_ID_LED_MAX); |
Rusty Russell | 1d8f430 | 2005-12-07 21:40:34 +0100 | [diff] [blame] | 810 | sprintf(alias + strlen(alias), "s*"); |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 811 | if (flags & INPUT_DEVICE_ID_MATCH_SNDBIT) |
| 812 | do_input(alias, *sndbit, 0, INPUT_DEVICE_ID_SND_MAX); |
Rusty Russell | 1d8f430 | 2005-12-07 21:40:34 +0100 | [diff] [blame] | 813 | sprintf(alias + strlen(alias), "f*"); |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 814 | if (flags & INPUT_DEVICE_ID_MATCH_FFBIT) |
| 815 | do_input(alias, *ffbit, 0, INPUT_DEVICE_ID_FF_MAX); |
Rusty Russell | 1d8f430 | 2005-12-07 21:40:34 +0100 | [diff] [blame] | 816 | sprintf(alias + strlen(alias), "w*"); |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 817 | if (flags & INPUT_DEVICE_ID_MATCH_SWBIT) |
| 818 | do_input(alias, *swbit, 0, INPUT_DEVICE_ID_SW_MAX); |
Rusty Russell | 1d8f430 | 2005-12-07 21:40:34 +0100 | [diff] [blame] | 819 | return 1; |
| 820 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 821 | ADD_TO_DEVTABLE("input", input_device_id, do_input_entry); |
Rusty Russell | 1d8f430 | 2005-12-07 21:40:34 +0100 | [diff] [blame] | 822 | |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 823 | static int do_eisa_entry(const char *filename, void *symval, |
Michael Tokarev | 07563c7 | 2006-09-27 01:50:56 -0700 | [diff] [blame] | 824 | char *alias) |
| 825 | { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 826 | DEF_FIELD_ADDR(symval, eisa_device_id, sig); |
| 827 | if (sig[0]) |
| 828 | sprintf(alias, EISA_DEVICE_MODALIAS_FMT "*", *sig); |
Jean Delvare | ac55182 | 2008-05-02 20:37:21 +0200 | [diff] [blame] | 829 | else |
| 830 | strcat(alias, "*"); |
Michael Tokarev | 07563c7 | 2006-09-27 01:50:56 -0700 | [diff] [blame] | 831 | return 1; |
| 832 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 833 | ADD_TO_DEVTABLE("eisa", eisa_device_id, do_eisa_entry); |
Michael Tokarev | 07563c7 | 2006-09-27 01:50:56 -0700 | [diff] [blame] | 834 | |
Kyle McMartin | f3cf267 | 2007-01-13 14:58:21 -0500 | [diff] [blame] | 835 | /* Looks like: parisc:tNhvNrevNsvN */ |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 836 | static int do_parisc_entry(const char *filename, void *symval, |
Kyle McMartin | f3cf267 | 2007-01-13 14:58:21 -0500 | [diff] [blame] | 837 | char *alias) |
| 838 | { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 839 | DEF_FIELD(symval, parisc_device_id, hw_type); |
| 840 | DEF_FIELD(symval, parisc_device_id, hversion); |
| 841 | DEF_FIELD(symval, parisc_device_id, hversion_rev); |
| 842 | DEF_FIELD(symval, parisc_device_id, sversion); |
Kyle McMartin | f3cf267 | 2007-01-13 14:58:21 -0500 | [diff] [blame] | 843 | |
| 844 | strcpy(alias, "parisc:"); |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 845 | ADD(alias, "t", hw_type != PA_HWTYPE_ANY_ID, hw_type); |
| 846 | ADD(alias, "hv", hversion != PA_HVERSION_ANY_ID, hversion); |
| 847 | ADD(alias, "rev", hversion_rev != PA_HVERSION_REV_ANY_ID, hversion_rev); |
| 848 | ADD(alias, "sv", sversion != PA_SVERSION_ANY_ID, sversion); |
Kyle McMartin | f3cf267 | 2007-01-13 14:58:21 -0500 | [diff] [blame] | 849 | |
Jean Delvare | ac55182 | 2008-05-02 20:37:21 +0200 | [diff] [blame] | 850 | add_wildcard(alias); |
Kyle McMartin | f3cf267 | 2007-01-13 14:58:21 -0500 | [diff] [blame] | 851 | return 1; |
| 852 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 853 | ADD_TO_DEVTABLE("parisc", parisc_device_id, do_parisc_entry); |
Kyle McMartin | f3cf267 | 2007-01-13 14:58:21 -0500 | [diff] [blame] | 854 | |
Pierre Ossman | d59b66c | 2007-06-17 11:34:23 +0200 | [diff] [blame] | 855 | /* Looks like: sdio:cNvNdN. */ |
| 856 | static int do_sdio_entry(const char *filename, |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 857 | void *symval, char *alias) |
Pierre Ossman | d59b66c | 2007-06-17 11:34:23 +0200 | [diff] [blame] | 858 | { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 859 | DEF_FIELD(symval, sdio_device_id, class); |
| 860 | DEF_FIELD(symval, sdio_device_id, vendor); |
| 861 | DEF_FIELD(symval, sdio_device_id, device); |
Pierre Ossman | d59b66c | 2007-06-17 11:34:23 +0200 | [diff] [blame] | 862 | |
| 863 | strcpy(alias, "sdio:"); |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 864 | ADD(alias, "c", class != (__u8)SDIO_ANY_ID, class); |
| 865 | ADD(alias, "v", vendor != (__u16)SDIO_ANY_ID, vendor); |
| 866 | ADD(alias, "d", device != (__u16)SDIO_ANY_ID, device); |
Jean Delvare | ac55182 | 2008-05-02 20:37:21 +0200 | [diff] [blame] | 867 | add_wildcard(alias); |
Linus Torvalds | 038a500 | 2007-10-11 19:40:14 -0700 | [diff] [blame] | 868 | return 1; |
| 869 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 870 | ADD_TO_DEVTABLE("sdio", sdio_device_id, do_sdio_entry); |
Pierre Ossman | d59b66c | 2007-06-17 11:34:23 +0200 | [diff] [blame] | 871 | |
Michael Buesch | 61e115a | 2007-09-18 15:12:50 -0400 | [diff] [blame] | 872 | /* Looks like: ssb:vNidNrevN. */ |
| 873 | static int do_ssb_entry(const char *filename, |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 874 | void *symval, char *alias) |
Michael Buesch | 61e115a | 2007-09-18 15:12:50 -0400 | [diff] [blame] | 875 | { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 876 | DEF_FIELD(symval, ssb_device_id, vendor); |
| 877 | DEF_FIELD(symval, ssb_device_id, coreid); |
| 878 | DEF_FIELD(symval, ssb_device_id, revision); |
Michael Buesch | 61e115a | 2007-09-18 15:12:50 -0400 | [diff] [blame] | 879 | |
| 880 | strcpy(alias, "ssb:"); |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 881 | ADD(alias, "v", vendor != SSB_ANY_VENDOR, vendor); |
| 882 | ADD(alias, "id", coreid != SSB_ANY_ID, coreid); |
| 883 | ADD(alias, "rev", revision != SSB_ANY_REV, revision); |
Jean Delvare | ac55182 | 2008-05-02 20:37:21 +0200 | [diff] [blame] | 884 | add_wildcard(alias); |
Pierre Ossman | d59b66c | 2007-06-17 11:34:23 +0200 | [diff] [blame] | 885 | return 1; |
| 886 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 887 | ADD_TO_DEVTABLE("ssb", ssb_device_id, do_ssb_entry); |
Pierre Ossman | d59b66c | 2007-06-17 11:34:23 +0200 | [diff] [blame] | 888 | |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 889 | /* Looks like: bcma:mNidNrevNclN. */ |
| 890 | static int do_bcma_entry(const char *filename, |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 891 | void *symval, char *alias) |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 892 | { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 893 | DEF_FIELD(symval, bcma_device_id, manuf); |
| 894 | DEF_FIELD(symval, bcma_device_id, id); |
| 895 | DEF_FIELD(symval, bcma_device_id, rev); |
| 896 | DEF_FIELD(symval, bcma_device_id, class); |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 897 | |
| 898 | strcpy(alias, "bcma:"); |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 899 | ADD(alias, "m", manuf != BCMA_ANY_MANUF, manuf); |
| 900 | ADD(alias, "id", id != BCMA_ANY_ID, id); |
| 901 | ADD(alias, "rev", rev != BCMA_ANY_REV, rev); |
| 902 | ADD(alias, "cl", class != BCMA_ANY_CLASS, class); |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 903 | add_wildcard(alias); |
| 904 | return 1; |
| 905 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 906 | ADD_TO_DEVTABLE("bcma", bcma_device_id, do_bcma_entry); |
Rafał Miłecki | 8369ae3 | 2011-05-09 18:56:46 +0200 | [diff] [blame] | 907 | |
Rusty Russell | b01d9f2 | 2007-10-22 11:03:39 +1000 | [diff] [blame] | 908 | /* Looks like: virtio:dNvN */ |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 909 | static int do_virtio_entry(const char *filename, void *symval, |
Rusty Russell | b01d9f2 | 2007-10-22 11:03:39 +1000 | [diff] [blame] | 910 | char *alias) |
| 911 | { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 912 | DEF_FIELD(symval, virtio_device_id, device); |
| 913 | DEF_FIELD(symval, virtio_device_id, vendor); |
Rusty Russell | b01d9f2 | 2007-10-22 11:03:39 +1000 | [diff] [blame] | 914 | |
| 915 | strcpy(alias, "virtio:"); |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 916 | ADD(alias, "d", device != VIRTIO_DEV_ANY_ID, device); |
| 917 | ADD(alias, "v", vendor != VIRTIO_DEV_ANY_ID, vendor); |
Rusty Russell | b01d9f2 | 2007-10-22 11:03:39 +1000 | [diff] [blame] | 918 | |
Jean Delvare | ac55182 | 2008-05-02 20:37:21 +0200 | [diff] [blame] | 919 | add_wildcard(alias); |
Rusty Russell | b01d9f2 | 2007-10-22 11:03:39 +1000 | [diff] [blame] | 920 | return 1; |
| 921 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 922 | ADD_TO_DEVTABLE("virtio", virtio_device_id, do_virtio_entry); |
Rusty Russell | b01d9f2 | 2007-10-22 11:03:39 +1000 | [diff] [blame] | 923 | |
K. Y. Srinivasan | d2ee52a | 2011-08-25 09:48:30 -0700 | [diff] [blame] | 924 | /* |
| 925 | * Looks like: vmbus:guid |
| 926 | * Each byte of the guid will be represented by two hex characters |
| 927 | * in the name. |
| 928 | */ |
| 929 | |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 930 | static int do_vmbus_entry(const char *filename, void *symval, |
K. Y. Srinivasan | d2ee52a | 2011-08-25 09:48:30 -0700 | [diff] [blame] | 931 | char *alias) |
| 932 | { |
| 933 | int i; |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 934 | DEF_FIELD_ADDR(symval, hv_vmbus_device_id, guid); |
| 935 | char guid_name[(sizeof(*guid) + 1) * 2]; |
K. Y. Srinivasan | d2ee52a | 2011-08-25 09:48:30 -0700 | [diff] [blame] | 936 | |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 937 | for (i = 0; i < (sizeof(*guid) * 2); i += 2) |
K. Y. Srinivasan | af3ff64 | 2015-12-14 16:01:43 -0800 | [diff] [blame] | 938 | sprintf(&guid_name[i], "%02x", TO_NATIVE((guid->b)[i/2])); |
K. Y. Srinivasan | d2ee52a | 2011-08-25 09:48:30 -0700 | [diff] [blame] | 939 | |
| 940 | strcpy(alias, "vmbus:"); |
| 941 | strcat(alias, guid_name); |
| 942 | |
| 943 | return 1; |
| 944 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 945 | ADD_TO_DEVTABLE("vmbus", hv_vmbus_device_id, do_vmbus_entry); |
K. Y. Srinivasan | d2ee52a | 2011-08-25 09:48:30 -0700 | [diff] [blame] | 946 | |
Jean Delvare | d2653e9 | 2008-04-29 23:11:39 +0200 | [diff] [blame] | 947 | /* Looks like: i2c:S */ |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 948 | static int do_i2c_entry(const char *filename, void *symval, |
Jean Delvare | d2653e9 | 2008-04-29 23:11:39 +0200 | [diff] [blame] | 949 | char *alias) |
| 950 | { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 951 | DEF_FIELD_ADDR(symval, i2c_device_id, name); |
| 952 | sprintf(alias, I2C_MODULE_PREFIX "%s", *name); |
Jean Delvare | d2653e9 | 2008-04-29 23:11:39 +0200 | [diff] [blame] | 953 | |
| 954 | return 1; |
| 955 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 956 | ADD_TO_DEVTABLE("i2c", i2c_device_id, do_i2c_entry); |
Jean Delvare | d2653e9 | 2008-04-29 23:11:39 +0200 | [diff] [blame] | 957 | |
Anton Vorontsov | e0626e3 | 2009-09-22 16:46:08 -0700 | [diff] [blame] | 958 | /* Looks like: spi:S */ |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 959 | static int do_spi_entry(const char *filename, void *symval, |
Anton Vorontsov | 75368bf | 2009-09-22 16:46:04 -0700 | [diff] [blame] | 960 | char *alias) |
| 961 | { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 962 | DEF_FIELD_ADDR(symval, spi_device_id, name); |
| 963 | sprintf(alias, SPI_MODULE_PREFIX "%s", *name); |
Anton Vorontsov | 75368bf | 2009-09-22 16:46:04 -0700 | [diff] [blame] | 964 | |
| 965 | return 1; |
| 966 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 967 | ADD_TO_DEVTABLE("spi", spi_device_id, do_spi_entry); |
Anton Vorontsov | 75368bf | 2009-09-22 16:46:04 -0700 | [diff] [blame] | 968 | |
David Woodhouse | d945b69 | 2008-09-16 16:23:28 -0700 | [diff] [blame] | 969 | static const struct dmifield { |
| 970 | const char *prefix; |
| 971 | int field; |
| 972 | } dmi_fields[] = { |
| 973 | { "bvn", DMI_BIOS_VENDOR }, |
| 974 | { "bvr", DMI_BIOS_VERSION }, |
| 975 | { "bd", DMI_BIOS_DATE }, |
| 976 | { "svn", DMI_SYS_VENDOR }, |
| 977 | { "pn", DMI_PRODUCT_NAME }, |
| 978 | { "pvr", DMI_PRODUCT_VERSION }, |
| 979 | { "rvn", DMI_BOARD_VENDOR }, |
| 980 | { "rn", DMI_BOARD_NAME }, |
| 981 | { "rvr", DMI_BOARD_VERSION }, |
| 982 | { "cvn", DMI_CHASSIS_VENDOR }, |
| 983 | { "ct", DMI_CHASSIS_TYPE }, |
| 984 | { "cvr", DMI_CHASSIS_VERSION }, |
| 985 | { NULL, DMI_NONE } |
| 986 | }; |
| 987 | |
| 988 | static void dmi_ascii_filter(char *d, const char *s) |
| 989 | { |
| 990 | /* Filter out characters we don't want to see in the modalias string */ |
| 991 | for (; *s; s++) |
| 992 | if (*s > ' ' && *s < 127 && *s != ':') |
| 993 | *(d++) = *s; |
| 994 | |
| 995 | *d = 0; |
| 996 | } |
| 997 | |
| 998 | |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 999 | static int do_dmi_entry(const char *filename, void *symval, |
David Woodhouse | d945b69 | 2008-09-16 16:23:28 -0700 | [diff] [blame] | 1000 | char *alias) |
| 1001 | { |
| 1002 | int i, j; |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1003 | DEF_FIELD_ADDR(symval, dmi_system_id, matches); |
David Woodhouse | d945b69 | 2008-09-16 16:23:28 -0700 | [diff] [blame] | 1004 | sprintf(alias, "dmi*"); |
| 1005 | |
| 1006 | for (i = 0; i < ARRAY_SIZE(dmi_fields); i++) { |
| 1007 | for (j = 0; j < 4; j++) { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1008 | if ((*matches)[j].slot && |
| 1009 | (*matches)[j].slot == dmi_fields[i].field) { |
David Woodhouse | d945b69 | 2008-09-16 16:23:28 -0700 | [diff] [blame] | 1010 | sprintf(alias + strlen(alias), ":%s*", |
| 1011 | dmi_fields[i].prefix); |
| 1012 | dmi_ascii_filter(alias + strlen(alias), |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1013 | (*matches)[j].substr); |
David Woodhouse | d945b69 | 2008-09-16 16:23:28 -0700 | [diff] [blame] | 1014 | strcat(alias, "*"); |
| 1015 | } |
| 1016 | } |
| 1017 | } |
| 1018 | |
| 1019 | strcat(alias, ":"); |
| 1020 | return 1; |
| 1021 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1022 | ADD_TO_DEVTABLE("dmi", dmi_system_id, do_dmi_entry); |
Eric Miao | 57fee4a | 2009-02-04 11:52:40 +0800 | [diff] [blame] | 1023 | |
| 1024 | static int do_platform_entry(const char *filename, |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1025 | void *symval, char *alias) |
Eric Miao | 57fee4a | 2009-02-04 11:52:40 +0800 | [diff] [blame] | 1026 | { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1027 | DEF_FIELD_ADDR(symval, platform_device_id, name); |
| 1028 | sprintf(alias, PLATFORM_MODULE_PREFIX "%s", *name); |
Eric Miao | 57fee4a | 2009-02-04 11:52:40 +0800 | [diff] [blame] | 1029 | return 1; |
| 1030 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1031 | ADD_TO_DEVTABLE("platform", platform_device_id, do_platform_entry); |
Eric Miao | 57fee4a | 2009-02-04 11:52:40 +0800 | [diff] [blame] | 1032 | |
David Woodhouse | 8626d3b | 2010-04-02 01:05:27 +0000 | [diff] [blame] | 1033 | static int do_mdio_entry(const char *filename, |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1034 | void *symval, char *alias) |
David Woodhouse | 8626d3b | 2010-04-02 01:05:27 +0000 | [diff] [blame] | 1035 | { |
| 1036 | int i; |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1037 | DEF_FIELD(symval, mdio_device_id, phy_id); |
| 1038 | DEF_FIELD(symval, mdio_device_id, phy_id_mask); |
David Woodhouse | 8626d3b | 2010-04-02 01:05:27 +0000 | [diff] [blame] | 1039 | |
| 1040 | alias += sprintf(alias, MDIO_MODULE_PREFIX); |
| 1041 | |
| 1042 | for (i = 0; i < 32; i++) { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1043 | if (!((phy_id_mask >> (31-i)) & 1)) |
David Woodhouse | 8626d3b | 2010-04-02 01:05:27 +0000 | [diff] [blame] | 1044 | *(alias++) = '?'; |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1045 | else if ((phy_id >> (31-i)) & 1) |
David Woodhouse | 8626d3b | 2010-04-02 01:05:27 +0000 | [diff] [blame] | 1046 | *(alias++) = '1'; |
| 1047 | else |
| 1048 | *(alias++) = '0'; |
| 1049 | } |
| 1050 | |
| 1051 | /* Terminate the string */ |
| 1052 | *alias = 0; |
| 1053 | |
| 1054 | return 1; |
| 1055 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1056 | ADD_TO_DEVTABLE("mdio", mdio_device_id, do_mdio_entry); |
David Woodhouse | 8626d3b | 2010-04-02 01:05:27 +0000 | [diff] [blame] | 1057 | |
Geert Uytterhoeven | bf54a2b | 2008-11-18 21:13:53 +0100 | [diff] [blame] | 1058 | /* Looks like: zorro:iN. */ |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1059 | static int do_zorro_entry(const char *filename, void *symval, |
Geert Uytterhoeven | bf54a2b | 2008-11-18 21:13:53 +0100 | [diff] [blame] | 1060 | char *alias) |
| 1061 | { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1062 | DEF_FIELD(symval, zorro_device_id, id); |
Geert Uytterhoeven | bf54a2b | 2008-11-18 21:13:53 +0100 | [diff] [blame] | 1063 | strcpy(alias, "zorro:"); |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1064 | ADD(alias, "i", id != ZORRO_WILDCARD, id); |
Geert Uytterhoeven | bf54a2b | 2008-11-18 21:13:53 +0100 | [diff] [blame] | 1065 | return 1; |
| 1066 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1067 | ADD_TO_DEVTABLE("zorro", zorro_device_id, do_zorro_entry); |
Geert Uytterhoeven | bf54a2b | 2008-11-18 21:13:53 +0100 | [diff] [blame] | 1068 | |
Ondrej Zary | fedb3d2 | 2009-12-18 20:52:39 +0100 | [diff] [blame] | 1069 | /* looks like: "pnp:dD" */ |
| 1070 | static int do_isapnp_entry(const char *filename, |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1071 | void *symval, char *alias) |
Ondrej Zary | fedb3d2 | 2009-12-18 20:52:39 +0100 | [diff] [blame] | 1072 | { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1073 | DEF_FIELD(symval, isapnp_device_id, vendor); |
| 1074 | DEF_FIELD(symval, isapnp_device_id, function); |
Ondrej Zary | fedb3d2 | 2009-12-18 20:52:39 +0100 | [diff] [blame] | 1075 | sprintf(alias, "pnp:d%c%c%c%x%x%x%x*", |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1076 | 'A' + ((vendor >> 2) & 0x3f) - 1, |
| 1077 | 'A' + (((vendor & 3) << 3) | ((vendor >> 13) & 7)) - 1, |
| 1078 | 'A' + ((vendor >> 8) & 0x1f) - 1, |
| 1079 | (function >> 4) & 0x0f, function & 0x0f, |
| 1080 | (function >> 12) & 0x0f, (function >> 8) & 0x0f); |
Ondrej Zary | fedb3d2 | 2009-12-18 20:52:39 +0100 | [diff] [blame] | 1081 | return 1; |
| 1082 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1083 | ADD_TO_DEVTABLE("isapnp", isapnp_device_id, do_isapnp_entry); |
Ondrej Zary | fedb3d2 | 2009-12-18 20:52:39 +0100 | [diff] [blame] | 1084 | |
Jens Taprogge | 849e0ad | 2012-09-04 17:01:13 +0200 | [diff] [blame] | 1085 | /* Looks like: "ipack:fNvNdN". */ |
| 1086 | static int do_ipack_entry(const char *filename, |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1087 | void *symval, char *alias) |
Jens Taprogge | 849e0ad | 2012-09-04 17:01:13 +0200 | [diff] [blame] | 1088 | { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1089 | DEF_FIELD(symval, ipack_device_id, format); |
| 1090 | DEF_FIELD(symval, ipack_device_id, vendor); |
| 1091 | DEF_FIELD(symval, ipack_device_id, device); |
Jens Taprogge | 849e0ad | 2012-09-04 17:01:13 +0200 | [diff] [blame] | 1092 | strcpy(alias, "ipack:"); |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1093 | ADD(alias, "f", format != IPACK_ANY_FORMAT, format); |
| 1094 | ADD(alias, "v", vendor != IPACK_ANY_ID, vendor); |
| 1095 | ADD(alias, "d", device != IPACK_ANY_ID, device); |
Jens Taprogge | 849e0ad | 2012-09-04 17:01:13 +0200 | [diff] [blame] | 1096 | add_wildcard(alias); |
| 1097 | return 1; |
| 1098 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1099 | ADD_TO_DEVTABLE("ipack", ipack_device_id, do_ipack_entry); |
Jens Taprogge | 849e0ad | 2012-09-04 17:01:13 +0200 | [diff] [blame] | 1100 | |
Dave Martin | 523817b | 2011-10-05 14:44:57 +0100 | [diff] [blame] | 1101 | /* |
| 1102 | * Append a match expression for a single masked hex digit. |
| 1103 | * outp points to a pointer to the character at which to append. |
| 1104 | * *outp is updated on return to point just after the appended text, |
| 1105 | * to facilitate further appending. |
| 1106 | */ |
| 1107 | static void append_nibble_mask(char **outp, |
| 1108 | unsigned int nibble, unsigned int mask) |
| 1109 | { |
| 1110 | char *p = *outp; |
| 1111 | unsigned int i; |
| 1112 | |
| 1113 | switch (mask) { |
| 1114 | case 0: |
| 1115 | *p++ = '?'; |
| 1116 | break; |
| 1117 | |
| 1118 | case 0xf: |
| 1119 | p += sprintf(p, "%X", nibble); |
| 1120 | break; |
| 1121 | |
| 1122 | default: |
| 1123 | /* |
| 1124 | * Dumbly emit a match pattern for all possible matching |
| 1125 | * digits. This could be improved in some cases using ranges, |
| 1126 | * but it has the advantage of being trivially correct, and is |
| 1127 | * often optimal. |
| 1128 | */ |
| 1129 | *p++ = '['; |
| 1130 | for (i = 0; i < 0x10; i++) |
| 1131 | if ((i & mask) == nibble) |
| 1132 | p += sprintf(p, "%X", i); |
| 1133 | *p++ = ']'; |
| 1134 | } |
| 1135 | |
| 1136 | /* Ensure that the string remains NUL-terminated: */ |
| 1137 | *p = '\0'; |
| 1138 | |
| 1139 | /* Advance the caller's end-of-string pointer: */ |
| 1140 | *outp = p; |
| 1141 | } |
| 1142 | |
| 1143 | /* |
| 1144 | * looks like: "amba:dN" |
| 1145 | * |
| 1146 | * N is exactly 8 digits, where each is an upper-case hex digit, or |
| 1147 | * a ? or [] pattern matching exactly one digit. |
| 1148 | */ |
| 1149 | static int do_amba_entry(const char *filename, |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1150 | void *symval, char *alias) |
Dave Martin | 523817b | 2011-10-05 14:44:57 +0100 | [diff] [blame] | 1151 | { |
| 1152 | unsigned int digit; |
| 1153 | char *p = alias; |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1154 | DEF_FIELD(symval, amba_id, id); |
| 1155 | DEF_FIELD(symval, amba_id, mask); |
Dave Martin | 523817b | 2011-10-05 14:44:57 +0100 | [diff] [blame] | 1156 | |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1157 | if ((id & mask) != id) |
Dave Martin | 523817b | 2011-10-05 14:44:57 +0100 | [diff] [blame] | 1158 | fatal("%s: Masked-off bit(s) of AMBA device ID are non-zero: " |
| 1159 | "id=0x%08X, mask=0x%08X. Please fix this driver.\n", |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1160 | filename, id, mask); |
Dave Martin | 523817b | 2011-10-05 14:44:57 +0100 | [diff] [blame] | 1161 | |
| 1162 | p += sprintf(alias, "amba:d"); |
| 1163 | for (digit = 0; digit < 8; digit++) |
| 1164 | append_nibble_mask(&p, |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1165 | (id >> (4 * (7 - digit))) & 0xf, |
| 1166 | (mask >> (4 * (7 - digit))) & 0xf); |
Dave Martin | 523817b | 2011-10-05 14:44:57 +0100 | [diff] [blame] | 1167 | |
| 1168 | return 1; |
| 1169 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1170 | ADD_TO_DEVTABLE("amba", amba_id, do_amba_entry); |
Dave Martin | 523817b | 2011-10-05 14:44:57 +0100 | [diff] [blame] | 1171 | |
James Hogan | 8286ae0 | 2015-03-25 15:39:50 +0000 | [diff] [blame] | 1172 | /* |
| 1173 | * looks like: "mipscdmm:tN" |
| 1174 | * |
| 1175 | * N is exactly 2 digits, where each is an upper-case hex digit, or |
| 1176 | * a ? or [] pattern matching exactly one digit. |
| 1177 | */ |
| 1178 | static int do_mips_cdmm_entry(const char *filename, |
| 1179 | void *symval, char *alias) |
| 1180 | { |
| 1181 | DEF_FIELD(symval, mips_cdmm_device_id, type); |
| 1182 | |
| 1183 | sprintf(alias, "mipscdmm:t%02X*", type); |
| 1184 | return 1; |
| 1185 | } |
| 1186 | ADD_TO_DEVTABLE("mipscdmm", mips_cdmm_device_id, do_mips_cdmm_entry); |
| 1187 | |
Ard Biesheuvel | 2b9c1f0 | 2014-02-08 13:34:10 +0100 | [diff] [blame] | 1188 | /* LOOKS like cpu:type:x86,venVVVVfamFFFFmodMMMM:feature:*,FEAT,* |
Andi Kleen | 644e9cb | 2012-01-26 00:09:05 +0100 | [diff] [blame] | 1189 | * All fields are numbers. It would be nicer to use strings for vendor |
| 1190 | * and feature, but getting those out of the build system here is too |
| 1191 | * complicated. |
| 1192 | */ |
| 1193 | |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1194 | static int do_x86cpu_entry(const char *filename, void *symval, |
Andi Kleen | 644e9cb | 2012-01-26 00:09:05 +0100 | [diff] [blame] | 1195 | char *alias) |
| 1196 | { |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1197 | DEF_FIELD(symval, x86_cpu_id, feature); |
| 1198 | DEF_FIELD(symval, x86_cpu_id, family); |
| 1199 | DEF_FIELD(symval, x86_cpu_id, model); |
| 1200 | DEF_FIELD(symval, x86_cpu_id, vendor); |
Andi Kleen | 644e9cb | 2012-01-26 00:09:05 +0100 | [diff] [blame] | 1201 | |
Ard Biesheuvel | 2b9c1f0 | 2014-02-08 13:34:10 +0100 | [diff] [blame] | 1202 | strcpy(alias, "cpu:type:x86,"); |
| 1203 | ADD(alias, "ven", vendor != X86_VENDOR_ANY, vendor); |
| 1204 | ADD(alias, "fam", family != X86_FAMILY_ANY, family); |
| 1205 | ADD(alias, "mod", model != X86_MODEL_ANY, model); |
Ben Hutchings | 5467bdd | 2012-02-11 22:57:19 +0000 | [diff] [blame] | 1206 | strcat(alias, ":feature:*"); |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1207 | if (feature != X86_FEATURE_ANY) |
| 1208 | sprintf(alias + strlen(alias), "%04X*", feature); |
Andi Kleen | 644e9cb | 2012-01-26 00:09:05 +0100 | [diff] [blame] | 1209 | return 1; |
| 1210 | } |
Andreas Schwab | 6543bec | 2013-01-20 17:58:47 +0100 | [diff] [blame] | 1211 | ADD_TO_DEVTABLE("x86cpu", x86_cpu_id, do_x86cpu_entry); |
Andi Kleen | 644e9cb | 2012-01-26 00:09:05 +0100 | [diff] [blame] | 1212 | |
Ard Biesheuvel | 67bad2f | 2014-02-08 13:34:09 +0100 | [diff] [blame] | 1213 | /* LOOKS like cpu:type:*:feature:*FEAT* */ |
| 1214 | static int do_cpu_entry(const char *filename, void *symval, char *alias) |
| 1215 | { |
| 1216 | DEF_FIELD(symval, cpu_feature, feature); |
| 1217 | |
| 1218 | sprintf(alias, "cpu:type:*:feature:*%04X*", feature); |
| 1219 | return 1; |
| 1220 | } |
| 1221 | ADD_TO_DEVTABLE("cpu", cpu_feature, do_cpu_entry); |
| 1222 | |
Tomas Winkler | b26864c | 2015-09-10 10:18:01 +0300 | [diff] [blame] | 1223 | /* Looks like: mei:S:uuid:N:* */ |
Samuel Ortiz | e535410 | 2013-03-27 17:29:53 +0200 | [diff] [blame] | 1224 | static int do_mei_entry(const char *filename, void *symval, |
| 1225 | char *alias) |
| 1226 | { |
| 1227 | DEF_FIELD_ADDR(symval, mei_cl_device_id, name); |
Tomas Winkler | c93b76b | 2015-05-07 15:54:02 +0300 | [diff] [blame] | 1228 | DEF_FIELD_ADDR(symval, mei_cl_device_id, uuid); |
Tomas Winkler | b26864c | 2015-09-10 10:18:01 +0300 | [diff] [blame] | 1229 | DEF_FIELD(symval, mei_cl_device_id, version); |
Samuel Ortiz | e535410 | 2013-03-27 17:29:53 +0200 | [diff] [blame] | 1230 | |
Tomas Winkler | c93b76b | 2015-05-07 15:54:02 +0300 | [diff] [blame] | 1231 | sprintf(alias, MEI_CL_MODULE_PREFIX); |
| 1232 | sprintf(alias + strlen(alias), "%s:", (*name)[0] ? *name : "*"); |
| 1233 | add_uuid(alias, *uuid); |
Tomas Winkler | b26864c | 2015-09-10 10:18:01 +0300 | [diff] [blame] | 1234 | ADD(alias, ":", version != MEI_CL_VERSION_ANY, version); |
Tomas Winkler | c93b76b | 2015-05-07 15:54:02 +0300 | [diff] [blame] | 1235 | |
| 1236 | strcat(alias, ":*"); |
Samuel Ortiz | e535410 | 2013-03-27 17:29:53 +0200 | [diff] [blame] | 1237 | |
| 1238 | return 1; |
| 1239 | } |
| 1240 | ADD_TO_DEVTABLE("mei", mei_cl_device_id, do_mei_entry); |
| 1241 | |
Alexandre Bounine | 3bdbb62 | 2013-07-03 15:08:58 -0700 | [diff] [blame] | 1242 | /* Looks like: rapidio:vNdNavNadN */ |
| 1243 | static int do_rio_entry(const char *filename, |
| 1244 | void *symval, char *alias) |
| 1245 | { |
| 1246 | DEF_FIELD(symval, rio_device_id, did); |
| 1247 | DEF_FIELD(symval, rio_device_id, vid); |
| 1248 | DEF_FIELD(symval, rio_device_id, asm_did); |
| 1249 | DEF_FIELD(symval, rio_device_id, asm_vid); |
| 1250 | |
| 1251 | strcpy(alias, "rapidio:"); |
| 1252 | ADD(alias, "v", vid != RIO_ANY_ID, vid); |
| 1253 | ADD(alias, "d", did != RIO_ANY_ID, did); |
| 1254 | ADD(alias, "av", asm_vid != RIO_ANY_ID, asm_vid); |
| 1255 | ADD(alias, "ad", asm_did != RIO_ANY_ID, asm_did); |
| 1256 | |
| 1257 | add_wildcard(alias); |
| 1258 | return 1; |
| 1259 | } |
| 1260 | ADD_TO_DEVTABLE("rapidio", rio_device_id, do_rio_entry); |
| 1261 | |
Heikki Krogerus | 289fcff | 2015-05-13 15:26:42 +0300 | [diff] [blame] | 1262 | /* Looks like: ulpi:vNpN */ |
| 1263 | static int do_ulpi_entry(const char *filename, void *symval, |
| 1264 | char *alias) |
| 1265 | { |
| 1266 | DEF_FIELD(symval, ulpi_device_id, vendor); |
| 1267 | DEF_FIELD(symval, ulpi_device_id, product); |
| 1268 | |
| 1269 | sprintf(alias, "ulpi:v%04xp%04x", vendor, product); |
| 1270 | |
| 1271 | return 1; |
| 1272 | } |
| 1273 | ADD_TO_DEVTABLE("ulpi", ulpi_device_id, do_ulpi_entry); |
| 1274 | |
Subhransu S. Prusty | da23ac1 | 2015-09-29 13:56:10 +0530 | [diff] [blame] | 1275 | /* Looks like: hdaudio:vNrNaN */ |
| 1276 | static int do_hda_entry(const char *filename, void *symval, char *alias) |
| 1277 | { |
| 1278 | DEF_FIELD(symval, hda_device_id, vendor_id); |
| 1279 | DEF_FIELD(symval, hda_device_id, rev_id); |
| 1280 | DEF_FIELD(symval, hda_device_id, api_version); |
| 1281 | |
| 1282 | strcpy(alias, "hdaudio:"); |
| 1283 | ADD(alias, "v", vendor_id != 0, vendor_id); |
| 1284 | ADD(alias, "r", rev_id != 0, rev_id); |
| 1285 | ADD(alias, "a", api_version != 0, api_version); |
| 1286 | |
| 1287 | add_wildcard(alias); |
| 1288 | return 1; |
| 1289 | } |
| 1290 | ADD_TO_DEVTABLE("hdaudio", hda_device_id, do_hda_entry); |
| 1291 | |
Rusty Russell | 626596e | 2012-01-13 09:32:15 +1030 | [diff] [blame] | 1292 | /* Does namelen bytes of name exactly match the symbol? */ |
| 1293 | static bool sym_is(const char *name, unsigned namelen, const char *symbol) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1294 | { |
Rusty Russell | 626596e | 2012-01-13 09:32:15 +1030 | [diff] [blame] | 1295 | if (namelen != strlen(symbol)) |
| 1296 | return false; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1297 | |
Rusty Russell | 626596e | 2012-01-13 09:32:15 +1030 | [diff] [blame] | 1298 | return memcmp(name, symbol, namelen) == 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1299 | } |
| 1300 | |
| 1301 | static void do_table(void *symval, unsigned long size, |
| 1302 | unsigned long id_size, |
Sam Ravnborg | fb33d81 | 2006-07-09 16:26:07 +0200 | [diff] [blame] | 1303 | const char *device_id, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1304 | void *function, |
| 1305 | struct module *mod) |
| 1306 | { |
| 1307 | unsigned int i; |
| 1308 | char alias[500]; |
| 1309 | int (*do_entry)(const char *, void *entry, char *alias) = function; |
| 1310 | |
Kees Cook | e004982 | 2007-09-16 11:15:46 +0200 | [diff] [blame] | 1311 | device_id_check(mod->name, device_id, size, id_size, symval); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1312 | /* Leave last one: it's the terminator. */ |
| 1313 | size -= id_size; |
| 1314 | |
| 1315 | for (i = 0; i < size; i += id_size) { |
| 1316 | if (do_entry(mod->name, symval+i, alias)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1317 | buf_printf(&mod->dev_table_buf, |
| 1318 | "MODULE_ALIAS(\"%s\");\n", alias); |
| 1319 | } |
| 1320 | } |
| 1321 | } |
| 1322 | |
| 1323 | /* Create MODULE_ALIAS() statements. |
| 1324 | * At this time, we cannot write the actual output C source yet, |
| 1325 | * so we write into the mod->dev_table_buf buffer. */ |
| 1326 | void handle_moddevtable(struct module *mod, struct elf_info *info, |
| 1327 | Elf_Sym *sym, const char *symname) |
| 1328 | { |
| 1329 | void *symval; |
Kees Cook | e004982 | 2007-09-16 11:15:46 +0200 | [diff] [blame] | 1330 | char *zeros = NULL; |
Tom Gundersen | 21bdd17 | 2014-02-03 11:14:13 +1030 | [diff] [blame] | 1331 | const char *name, *identifier; |
Rusty Russell | 626596e | 2012-01-13 09:32:15 +1030 | [diff] [blame] | 1332 | unsigned int namelen; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1333 | |
| 1334 | /* We're looking for a section relative symbol */ |
Denys Vlasenko | 1ce53ad | 2010-07-29 01:47:53 +0200 | [diff] [blame] | 1335 | if (!sym->st_shndx || get_secindex(info, sym) >= info->num_sections) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1336 | return; |
| 1337 | |
David Miller | e88aa7b | 2012-04-12 14:37:30 -0400 | [diff] [blame] | 1338 | /* We're looking for an object */ |
| 1339 | if (ELF_ST_TYPE(sym->st_info) != STT_OBJECT) |
| 1340 | return; |
| 1341 | |
Tom Gundersen | 21bdd17 | 2014-02-03 11:14:13 +1030 | [diff] [blame] | 1342 | /* All our symbols are of form <prefix>__mod_<name>__<identifier>_device_table. */ |
Rusty Russell | 626596e | 2012-01-13 09:32:15 +1030 | [diff] [blame] | 1343 | name = strstr(symname, "__mod_"); |
| 1344 | if (!name) |
| 1345 | return; |
| 1346 | name += strlen("__mod_"); |
| 1347 | namelen = strlen(name); |
| 1348 | if (namelen < strlen("_device_table")) |
| 1349 | return; |
| 1350 | if (strcmp(name + namelen - strlen("_device_table"), "_device_table")) |
| 1351 | return; |
Tom Gundersen | 21bdd17 | 2014-02-03 11:14:13 +1030 | [diff] [blame] | 1352 | identifier = strstr(name, "__"); |
| 1353 | if (!identifier) |
| 1354 | return; |
| 1355 | namelen = identifier - name; |
Rusty Russell | 626596e | 2012-01-13 09:32:15 +1030 | [diff] [blame] | 1356 | |
Kees Cook | e004982 | 2007-09-16 11:15:46 +0200 | [diff] [blame] | 1357 | /* Handle all-NULL symbols allocated into .bss */ |
Denys Vlasenko | 1ce53ad | 2010-07-29 01:47:53 +0200 | [diff] [blame] | 1358 | if (info->sechdrs[get_secindex(info, sym)].sh_type & SHT_NOBITS) { |
Kees Cook | e004982 | 2007-09-16 11:15:46 +0200 | [diff] [blame] | 1359 | zeros = calloc(1, sym->st_size); |
| 1360 | symval = zeros; |
| 1361 | } else { |
| 1362 | symval = (void *)info->hdr |
Denys Vlasenko | 1ce53ad | 2010-07-29 01:47:53 +0200 | [diff] [blame] | 1363 | + info->sechdrs[get_secindex(info, sym)].sh_offset |
Kees Cook | e004982 | 2007-09-16 11:15:46 +0200 | [diff] [blame] | 1364 | + sym->st_value; |
| 1365 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1366 | |
Rusty Russell | 626596e | 2012-01-13 09:32:15 +1030 | [diff] [blame] | 1367 | /* First handle the "special" cases */ |
| 1368 | if (sym_is(name, namelen, "usb")) |
Roman Kagan | b19dcd9 | 2005-04-22 15:07:01 -0700 | [diff] [blame] | 1369 | do_usb_table(symval, sym->st_size, mod); |
Philipp Zabel | acbef7b | 2016-05-05 16:22:29 -0700 | [diff] [blame] | 1370 | if (sym_is(name, namelen, "of")) |
| 1371 | do_of_table(symval, sym->st_size, mod); |
Rusty Russell | 626596e | 2012-01-13 09:32:15 +1030 | [diff] [blame] | 1372 | else if (sym_is(name, namelen, "pnp")) |
Kay Sievers | 22454cb | 2008-05-28 23:06:47 +0200 | [diff] [blame] | 1373 | do_pnp_device_entry(symval, sym->st_size, mod); |
Rusty Russell | 626596e | 2012-01-13 09:32:15 +1030 | [diff] [blame] | 1374 | else if (sym_is(name, namelen, "pnp_card")) |
Kay Sievers | 0c81eed | 2008-02-21 00:35:54 +0100 | [diff] [blame] | 1375 | do_pnp_card_entries(symval, sym->st_size, mod); |
Rusty Russell | 626596e | 2012-01-13 09:32:15 +1030 | [diff] [blame] | 1376 | else { |
Rusty Russell | e49ce14 | 2012-01-13 09:32:16 +1030 | [diff] [blame] | 1377 | struct devtable **p; |
Andreas Bießmann | dd2a3ac | 2012-02-24 08:23:53 +0100 | [diff] [blame] | 1378 | INIT_SECTION(__devtable); |
Rusty Russell | 626596e | 2012-01-13 09:32:15 +1030 | [diff] [blame] | 1379 | |
Rusty Russell | e49ce14 | 2012-01-13 09:32:16 +1030 | [diff] [blame] | 1380 | for (p = __start___devtable; p < __stop___devtable; p++) { |
| 1381 | if (sym_is(name, namelen, (*p)->device_id)) { |
| 1382 | do_table(symval, sym->st_size, (*p)->id_size, |
| 1383 | (*p)->device_id, (*p)->function, mod); |
Rusty Russell | 626596e | 2012-01-13 09:32:15 +1030 | [diff] [blame] | 1384 | break; |
| 1385 | } |
| 1386 | } |
| 1387 | } |
Kees Cook | e004982 | 2007-09-16 11:15:46 +0200 | [diff] [blame] | 1388 | free(zeros); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1389 | } |
| 1390 | |
| 1391 | /* Now add out buffered information to the generated C source */ |
| 1392 | void add_moddevtable(struct buffer *buf, struct module *mod) |
| 1393 | { |
| 1394 | buf_printf(buf, "\n"); |
| 1395 | buf_write(buf, mod->dev_table_buf.p, mod->dev_table_buf.pos); |
| 1396 | free(mod->dev_table_buf.p); |
| 1397 | } |