11da177e4SLinus Torvalds /* Simple code to turn various tables in an ELF file into alias definitions. 21da177e4SLinus Torvalds * This deals with kernel datastructures where they should be 31da177e4SLinus Torvalds * dealt with: in the kernel source. 41da177e4SLinus Torvalds * 51da177e4SLinus Torvalds * Copyright 2002-2003 Rusty Russell, IBM Corporation 61da177e4SLinus Torvalds * 2003 Kai Germaschewski 71da177e4SLinus Torvalds * 81da177e4SLinus Torvalds * 91da177e4SLinus Torvalds * This software may be used and distributed according to the terms 101da177e4SLinus Torvalds * of the GNU General Public License, incorporated herein by reference. 111da177e4SLinus Torvalds */ 121da177e4SLinus Torvalds 131da177e4SLinus Torvalds #include "modpost.h" 141da177e4SLinus Torvalds 151da177e4SLinus Torvalds /* We use the ELF typedefs for kernel_ulong_t but bite the bullet and 161da177e4SLinus Torvalds * use either stdint.h or inttypes.h for the rest. */ 171da177e4SLinus Torvalds #if KERNEL_ELFCLASS == ELFCLASS32 181da177e4SLinus Torvalds typedef Elf32_Addr kernel_ulong_t; 191d8f430cSRusty Russell #define BITS_PER_LONG 32 201da177e4SLinus Torvalds #else 211da177e4SLinus Torvalds typedef Elf64_Addr kernel_ulong_t; 221d8f430cSRusty Russell #define BITS_PER_LONG 64 231da177e4SLinus Torvalds #endif 241da177e4SLinus Torvalds #ifdef __sun__ 251da177e4SLinus Torvalds #include <inttypes.h> 261da177e4SLinus Torvalds #else 271da177e4SLinus Torvalds #include <stdint.h> 281da177e4SLinus Torvalds #endif 291da177e4SLinus Torvalds 305e655772SJeff Mahoney #include <ctype.h> 315e655772SJeff Mahoney 321da177e4SLinus Torvalds typedef uint32_t __u32; 331da177e4SLinus Torvalds typedef uint16_t __u16; 341da177e4SLinus Torvalds typedef unsigned char __u8; 351da177e4SLinus Torvalds 361da177e4SLinus Torvalds /* Big exception to the "don't include kernel headers into userspace, which 371da177e4SLinus Torvalds * even potentially has different endianness and word sizes, since 381da177e4SLinus Torvalds * we handle those differences explicitly below */ 391da177e4SLinus Torvalds #include "../../include/linux/mod_devicetable.h" 401da177e4SLinus Torvalds 411da177e4SLinus Torvalds #define ADD(str, sep, cond, field) \ 421da177e4SLinus Torvalds do { \ 431da177e4SLinus Torvalds strcat(str, sep); \ 441da177e4SLinus Torvalds if (cond) \ 451da177e4SLinus Torvalds sprintf(str + strlen(str), \ 461da177e4SLinus Torvalds sizeof(field) == 1 ? "%02X" : \ 471da177e4SLinus Torvalds sizeof(field) == 2 ? "%04X" : \ 481da177e4SLinus Torvalds sizeof(field) == 4 ? "%08X" : "", \ 491da177e4SLinus Torvalds field); \ 501da177e4SLinus Torvalds else \ 511da177e4SLinus Torvalds sprintf(str + strlen(str), "*"); \ 521da177e4SLinus Torvalds } while(0) 531da177e4SLinus Torvalds 54ac551828SJean Delvare /* Always end in a wildcard, for future extension */ 55ac551828SJean Delvare static inline void add_wildcard(char *str) 56ac551828SJean Delvare { 57ac551828SJean Delvare int len = strlen(str); 58ac551828SJean Delvare 59ac551828SJean Delvare if (str[len - 1] != '*') 60ac551828SJean Delvare strcat(str + len, "*"); 61ac551828SJean Delvare } 62ac551828SJean Delvare 634ce6efedSSam Ravnborg unsigned int cross_build = 0; 64fb33d816SSam Ravnborg /** 65fb33d816SSam Ravnborg * Check that sizeof(device_id type) are consistent with size of section 66fb33d816SSam Ravnborg * in .o file. If in-consistent then userspace and kernel does not agree 67fb33d816SSam Ravnborg * on actual size which is a bug. 68e0049825SKees Cook * Also verify that the final entry in the table is all zeros. 694ce6efedSSam Ravnborg * Ignore both checks if build host differ from target host and size differs. 70fb33d816SSam Ravnborg **/ 71e0049825SKees Cook static void device_id_check(const char *modname, const char *device_id, 72e0049825SKees Cook unsigned long size, unsigned long id_size, 73e0049825SKees Cook void *symval) 74fb33d816SSam Ravnborg { 75e0049825SKees Cook int i; 76e0049825SKees Cook 77fb33d816SSam Ravnborg if (size % id_size || size < id_size) { 784ce6efedSSam Ravnborg if (cross_build != 0) 794ce6efedSSam Ravnborg return; 80fb33d816SSam Ravnborg fatal("%s: sizeof(struct %s_device_id)=%lu is not a modulo " 81fb33d816SSam Ravnborg "of the size of section __mod_%s_device_table=%lu.\n" 82fb33d816SSam Ravnborg "Fix definition of struct %s_device_id " 83fb33d816SSam Ravnborg "in mod_devicetable.h\n", 84fb33d816SSam Ravnborg modname, device_id, id_size, device_id, size, device_id); 85fb33d816SSam Ravnborg } 86e0049825SKees Cook /* Verify last one is a terminator */ 87e0049825SKees Cook for (i = 0; i < id_size; i++ ) { 88e0049825SKees Cook if (*(uint8_t*)(symval+size-id_size+i)) { 89e0049825SKees Cook fprintf(stderr,"%s: struct %s_device_id is %lu bytes. " 90e0049825SKees Cook "The last of %lu is:\n", 91e0049825SKees Cook modname, device_id, id_size, size / id_size); 92e0049825SKees Cook for (i = 0; i < id_size; i++ ) 93e0049825SKees Cook fprintf(stderr,"0x%02x ", 94e0049825SKees Cook *(uint8_t*)(symval+size-id_size+i) ); 95e0049825SKees Cook fprintf(stderr,"\n"); 96e0049825SKees Cook fatal("%s: struct %s_device_id is not terminated " 97e0049825SKees Cook "with a NULL entry!\n", modname, device_id); 98e0049825SKees Cook } 99e0049825SKees Cook } 100fb33d816SSam Ravnborg } 101fb33d816SSam Ravnborg 102b19dcd93SRoman Kagan /* USB is special because the bcdDevice can be matched against a numeric range */ 103b19dcd93SRoman Kagan /* Looks like "usb:vNpNdNdcNdscNdpNicNiscNipN" */ 104b19dcd93SRoman Kagan static void do_usb_entry(struct usb_device_id *id, 105b19dcd93SRoman Kagan unsigned int bcdDevice_initial, int bcdDevice_initial_digits, 106b19dcd93SRoman Kagan unsigned char range_lo, unsigned char range_hi, 107b19dcd93SRoman Kagan struct module *mod) 1081da177e4SLinus Torvalds { 109b19dcd93SRoman Kagan char alias[500]; 1101da177e4SLinus Torvalds strcpy(alias, "usb:"); 1111da177e4SLinus Torvalds ADD(alias, "v", id->match_flags&USB_DEVICE_ID_MATCH_VENDOR, 1121da177e4SLinus Torvalds id->idVendor); 1131da177e4SLinus Torvalds ADD(alias, "p", id->match_flags&USB_DEVICE_ID_MATCH_PRODUCT, 1141da177e4SLinus Torvalds id->idProduct); 115b19dcd93SRoman Kagan 116b19dcd93SRoman Kagan strcat(alias, "d"); 117b19dcd93SRoman Kagan if (bcdDevice_initial_digits) 118b19dcd93SRoman Kagan sprintf(alias + strlen(alias), "%0*X", 119b19dcd93SRoman Kagan bcdDevice_initial_digits, bcdDevice_initial); 120b19dcd93SRoman Kagan if (range_lo == range_hi) 121b19dcd93SRoman Kagan sprintf(alias + strlen(alias), "%u", range_lo); 122b19dcd93SRoman Kagan else if (range_lo > 0 || range_hi < 9) 123b19dcd93SRoman Kagan sprintf(alias + strlen(alias), "[%u-%u]", range_lo, range_hi); 124b19dcd93SRoman Kagan if (bcdDevice_initial_digits < (sizeof(id->bcdDevice_lo) * 2 - 1)) 125b19dcd93SRoman Kagan strcat(alias, "*"); 126b19dcd93SRoman Kagan 1271da177e4SLinus Torvalds ADD(alias, "dc", id->match_flags&USB_DEVICE_ID_MATCH_DEV_CLASS, 1281da177e4SLinus Torvalds id->bDeviceClass); 1291da177e4SLinus Torvalds ADD(alias, "dsc", 1301da177e4SLinus Torvalds id->match_flags&USB_DEVICE_ID_MATCH_DEV_SUBCLASS, 1311da177e4SLinus Torvalds id->bDeviceSubClass); 1321da177e4SLinus Torvalds ADD(alias, "dp", 1331da177e4SLinus Torvalds id->match_flags&USB_DEVICE_ID_MATCH_DEV_PROTOCOL, 1341da177e4SLinus Torvalds id->bDeviceProtocol); 1351da177e4SLinus Torvalds ADD(alias, "ic", 1361da177e4SLinus Torvalds id->match_flags&USB_DEVICE_ID_MATCH_INT_CLASS, 1371da177e4SLinus Torvalds id->bInterfaceClass); 1381da177e4SLinus Torvalds ADD(alias, "isc", 1391da177e4SLinus Torvalds id->match_flags&USB_DEVICE_ID_MATCH_INT_SUBCLASS, 1401da177e4SLinus Torvalds id->bInterfaceSubClass); 1411da177e4SLinus Torvalds ADD(alias, "ip", 1421da177e4SLinus Torvalds id->match_flags&USB_DEVICE_ID_MATCH_INT_PROTOCOL, 1431da177e4SLinus Torvalds id->bInterfaceProtocol); 144b19dcd93SRoman Kagan 145ac551828SJean Delvare add_wildcard(alias); 146b19dcd93SRoman Kagan buf_printf(&mod->dev_table_buf, 147b19dcd93SRoman Kagan "MODULE_ALIAS(\"%s\");\n", alias); 148b19dcd93SRoman Kagan } 149b19dcd93SRoman Kagan 150b19dcd93SRoman Kagan static void do_usb_entry_multi(struct usb_device_id *id, struct module *mod) 151b19dcd93SRoman Kagan { 152b19dcd93SRoman Kagan unsigned int devlo, devhi; 153b19dcd93SRoman Kagan unsigned char chi, clo; 154b19dcd93SRoman Kagan int ndigits; 155b19dcd93SRoman Kagan 156b19dcd93SRoman Kagan id->match_flags = TO_NATIVE(id->match_flags); 157b19dcd93SRoman Kagan id->idVendor = TO_NATIVE(id->idVendor); 158b19dcd93SRoman Kagan id->idProduct = TO_NATIVE(id->idProduct); 159b19dcd93SRoman Kagan 160b19dcd93SRoman Kagan devlo = id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO ? 161b19dcd93SRoman Kagan TO_NATIVE(id->bcdDevice_lo) : 0x0U; 162b19dcd93SRoman Kagan devhi = id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI ? 163b19dcd93SRoman Kagan TO_NATIVE(id->bcdDevice_hi) : ~0x0U; 164b19dcd93SRoman Kagan 165b19dcd93SRoman Kagan /* 166b19dcd93SRoman Kagan * Some modules (visor) have empty slots as placeholder for 167b19dcd93SRoman Kagan * run-time specification that results in catch-all alias 168b19dcd93SRoman Kagan */ 169de6f92b9SGreg Kroah-Hartman if (!(id->idVendor | id->idProduct | id->bDeviceClass | id->bInterfaceClass)) 170b19dcd93SRoman Kagan return; 171b19dcd93SRoman Kagan 172b19dcd93SRoman Kagan /* Convert numeric bcdDevice range into fnmatch-able pattern(s) */ 173b19dcd93SRoman Kagan for (ndigits = sizeof(id->bcdDevice_lo) * 2 - 1; devlo <= devhi; ndigits--) { 174b19dcd93SRoman Kagan clo = devlo & 0xf; 175b19dcd93SRoman Kagan chi = devhi & 0xf; 176b19dcd93SRoman Kagan if (chi > 9) /* it's bcd not hex */ 177b19dcd93SRoman Kagan chi = 9; 178b19dcd93SRoman Kagan devlo >>= 4; 179b19dcd93SRoman Kagan devhi >>= 4; 180b19dcd93SRoman Kagan 181b19dcd93SRoman Kagan if (devlo == devhi || !ndigits) { 182b19dcd93SRoman Kagan do_usb_entry(id, devlo, ndigits, clo, chi, mod); 183b19dcd93SRoman Kagan break; 184b19dcd93SRoman Kagan } 185b19dcd93SRoman Kagan 186b19dcd93SRoman Kagan if (clo > 0) 187b19dcd93SRoman Kagan do_usb_entry(id, devlo++, ndigits, clo, 9, mod); 188b19dcd93SRoman Kagan 189b19dcd93SRoman Kagan if (chi < 9) 190b19dcd93SRoman Kagan do_usb_entry(id, devhi--, ndigits, 0, chi, mod); 191b19dcd93SRoman Kagan } 192b19dcd93SRoman Kagan } 193b19dcd93SRoman Kagan 194b19dcd93SRoman Kagan static void do_usb_table(void *symval, unsigned long size, 195b19dcd93SRoman Kagan struct module *mod) 196b19dcd93SRoman Kagan { 197b19dcd93SRoman Kagan unsigned int i; 198b19dcd93SRoman Kagan const unsigned long id_size = sizeof(struct usb_device_id); 199b19dcd93SRoman Kagan 200e0049825SKees Cook device_id_check(mod->name, "usb", size, id_size, symval); 201fb33d816SSam Ravnborg 202b19dcd93SRoman Kagan /* Leave last one: it's the terminator. */ 203b19dcd93SRoman Kagan size -= id_size; 204b19dcd93SRoman Kagan 205b19dcd93SRoman Kagan for (i = 0; i < size; i += id_size) 206b19dcd93SRoman Kagan do_usb_entry_multi(symval + i, mod); 2071da177e4SLinus Torvalds } 2081da177e4SLinus Torvalds 2091da177e4SLinus Torvalds /* Looks like: ieee1394:venNmoNspNverN */ 2101da177e4SLinus Torvalds static int do_ieee1394_entry(const char *filename, 2111da177e4SLinus Torvalds struct ieee1394_device_id *id, char *alias) 2121da177e4SLinus Torvalds { 2131da177e4SLinus Torvalds id->match_flags = TO_NATIVE(id->match_flags); 2141da177e4SLinus Torvalds id->vendor_id = TO_NATIVE(id->vendor_id); 2151da177e4SLinus Torvalds id->model_id = TO_NATIVE(id->model_id); 2161da177e4SLinus Torvalds id->specifier_id = TO_NATIVE(id->specifier_id); 2171da177e4SLinus Torvalds id->version = TO_NATIVE(id->version); 2181da177e4SLinus Torvalds 2191da177e4SLinus Torvalds strcpy(alias, "ieee1394:"); 2201da177e4SLinus Torvalds ADD(alias, "ven", id->match_flags & IEEE1394_MATCH_VENDOR_ID, 2211da177e4SLinus Torvalds id->vendor_id); 2221da177e4SLinus Torvalds ADD(alias, "mo", id->match_flags & IEEE1394_MATCH_MODEL_ID, 2231da177e4SLinus Torvalds id->model_id); 2241da177e4SLinus Torvalds ADD(alias, "sp", id->match_flags & IEEE1394_MATCH_SPECIFIER_ID, 2251da177e4SLinus Torvalds id->specifier_id); 2261da177e4SLinus Torvalds ADD(alias, "ver", id->match_flags & IEEE1394_MATCH_VERSION, 2271da177e4SLinus Torvalds id->version); 2281da177e4SLinus Torvalds 229ac551828SJean Delvare add_wildcard(alias); 2301da177e4SLinus Torvalds return 1; 2311da177e4SLinus Torvalds } 2321da177e4SLinus Torvalds 2331da177e4SLinus Torvalds /* Looks like: pci:vNdNsvNsdNbcNscNiN. */ 2341da177e4SLinus Torvalds static int do_pci_entry(const char *filename, 2351da177e4SLinus Torvalds struct pci_device_id *id, char *alias) 2361da177e4SLinus Torvalds { 2371da177e4SLinus Torvalds /* Class field can be divided into these three. */ 2381da177e4SLinus Torvalds unsigned char baseclass, subclass, interface, 2391da177e4SLinus Torvalds baseclass_mask, subclass_mask, interface_mask; 2401da177e4SLinus Torvalds 2411da177e4SLinus Torvalds id->vendor = TO_NATIVE(id->vendor); 2421da177e4SLinus Torvalds id->device = TO_NATIVE(id->device); 2431da177e4SLinus Torvalds id->subvendor = TO_NATIVE(id->subvendor); 2441da177e4SLinus Torvalds id->subdevice = TO_NATIVE(id->subdevice); 2451da177e4SLinus Torvalds id->class = TO_NATIVE(id->class); 2461da177e4SLinus Torvalds id->class_mask = TO_NATIVE(id->class_mask); 2471da177e4SLinus Torvalds 2481da177e4SLinus Torvalds strcpy(alias, "pci:"); 2491da177e4SLinus Torvalds ADD(alias, "v", id->vendor != PCI_ANY_ID, id->vendor); 2501da177e4SLinus Torvalds ADD(alias, "d", id->device != PCI_ANY_ID, id->device); 2511da177e4SLinus Torvalds ADD(alias, "sv", id->subvendor != PCI_ANY_ID, id->subvendor); 2521da177e4SLinus Torvalds ADD(alias, "sd", id->subdevice != PCI_ANY_ID, id->subdevice); 2531da177e4SLinus Torvalds 2541da177e4SLinus Torvalds baseclass = (id->class) >> 16; 2551da177e4SLinus Torvalds baseclass_mask = (id->class_mask) >> 16; 2561da177e4SLinus Torvalds subclass = (id->class) >> 8; 2571da177e4SLinus Torvalds subclass_mask = (id->class_mask) >> 8; 2581da177e4SLinus Torvalds interface = id->class; 2591da177e4SLinus Torvalds interface_mask = id->class_mask; 2601da177e4SLinus Torvalds 2611da177e4SLinus Torvalds if ((baseclass_mask != 0 && baseclass_mask != 0xFF) 2621da177e4SLinus Torvalds || (subclass_mask != 0 && subclass_mask != 0xFF) 2631da177e4SLinus Torvalds || (interface_mask != 0 && interface_mask != 0xFF)) { 264cb80514dSSam Ravnborg warn("Can't handle masks in %s:%04X\n", 2651da177e4SLinus Torvalds filename, id->class_mask); 2661da177e4SLinus Torvalds return 0; 2671da177e4SLinus Torvalds } 2681da177e4SLinus Torvalds 2691da177e4SLinus Torvalds ADD(alias, "bc", baseclass_mask == 0xFF, baseclass); 2701da177e4SLinus Torvalds ADD(alias, "sc", subclass_mask == 0xFF, subclass); 2711da177e4SLinus Torvalds ADD(alias, "i", interface_mask == 0xFF, interface); 272ac551828SJean Delvare add_wildcard(alias); 2731da177e4SLinus Torvalds return 1; 2741da177e4SLinus Torvalds } 2751da177e4SLinus Torvalds 2761da177e4SLinus Torvalds /* looks like: "ccw:tNmNdtNdmN" */ 2771da177e4SLinus Torvalds static int do_ccw_entry(const char *filename, 2781da177e4SLinus Torvalds struct ccw_device_id *id, char *alias) 2791da177e4SLinus Torvalds { 2801da177e4SLinus Torvalds id->match_flags = TO_NATIVE(id->match_flags); 2811da177e4SLinus Torvalds id->cu_type = TO_NATIVE(id->cu_type); 2821da177e4SLinus Torvalds id->cu_model = TO_NATIVE(id->cu_model); 2831da177e4SLinus Torvalds id->dev_type = TO_NATIVE(id->dev_type); 2841da177e4SLinus Torvalds id->dev_model = TO_NATIVE(id->dev_model); 2851da177e4SLinus Torvalds 2861da177e4SLinus Torvalds strcpy(alias, "ccw:"); 2871da177e4SLinus Torvalds ADD(alias, "t", id->match_flags&CCW_DEVICE_ID_MATCH_CU_TYPE, 2881da177e4SLinus Torvalds id->cu_type); 2891da177e4SLinus Torvalds ADD(alias, "m", id->match_flags&CCW_DEVICE_ID_MATCH_CU_MODEL, 2901da177e4SLinus Torvalds id->cu_model); 2911da177e4SLinus Torvalds ADD(alias, "dt", id->match_flags&CCW_DEVICE_ID_MATCH_DEVICE_TYPE, 2921da177e4SLinus Torvalds id->dev_type); 293de1d9c03SBastian Blank ADD(alias, "dm", id->match_flags&CCW_DEVICE_ID_MATCH_DEVICE_MODEL, 2941da177e4SLinus Torvalds id->dev_model); 295ac551828SJean Delvare add_wildcard(alias); 2961da177e4SLinus Torvalds return 1; 2971da177e4SLinus Torvalds } 2981da177e4SLinus Torvalds 2991534c382SMartin Schwidefsky /* looks like: "ap:tN" */ 3001534c382SMartin Schwidefsky static int do_ap_entry(const char *filename, 3011534c382SMartin Schwidefsky struct ap_device_id *id, char *alias) 3021534c382SMartin Schwidefsky { 303ac551828SJean Delvare sprintf(alias, "ap:t%02X*", id->dev_type); 3041534c382SMartin Schwidefsky return 1; 3051534c382SMartin Schwidefsky } 3061534c382SMartin Schwidefsky 307*7e9db9eaSCornelia Huck /* looks like: "css:tN" */ 308*7e9db9eaSCornelia Huck static int do_css_entry(const char *filename, 309*7e9db9eaSCornelia Huck struct css_device_id *id, char *alias) 310*7e9db9eaSCornelia Huck { 311*7e9db9eaSCornelia Huck sprintf(alias, "css:t%01X", id->type); 312*7e9db9eaSCornelia Huck return 1; 313*7e9db9eaSCornelia Huck } 314*7e9db9eaSCornelia Huck 3151da177e4SLinus Torvalds /* Looks like: "serio:tyNprNidNexN" */ 3161da177e4SLinus Torvalds static int do_serio_entry(const char *filename, 3171da177e4SLinus Torvalds struct serio_device_id *id, char *alias) 3181da177e4SLinus Torvalds { 3191da177e4SLinus Torvalds id->type = TO_NATIVE(id->type); 3201da177e4SLinus Torvalds id->proto = TO_NATIVE(id->proto); 3211da177e4SLinus Torvalds id->id = TO_NATIVE(id->id); 3221da177e4SLinus Torvalds id->extra = TO_NATIVE(id->extra); 3231da177e4SLinus Torvalds 3241da177e4SLinus Torvalds strcpy(alias, "serio:"); 3251da177e4SLinus Torvalds ADD(alias, "ty", id->type != SERIO_ANY, id->type); 3261da177e4SLinus Torvalds ADD(alias, "pr", id->proto != SERIO_ANY, id->proto); 3271da177e4SLinus Torvalds ADD(alias, "id", id->id != SERIO_ANY, id->id); 3281da177e4SLinus Torvalds ADD(alias, "ex", id->extra != SERIO_ANY, id->extra); 3291da177e4SLinus Torvalds 330ac551828SJean Delvare add_wildcard(alias); 3311da177e4SLinus Torvalds return 1; 3321da177e4SLinus Torvalds } 3331da177e4SLinus Torvalds 33429b71a1cSThomas Renninger /* looks like: "acpi:ACPI0003 or acpi:PNP0C0B" or "acpi:LNXVIDEO" */ 33529b71a1cSThomas Renninger static int do_acpi_entry(const char *filename, 33629b71a1cSThomas Renninger struct acpi_device_id *id, char *alias) 33729b71a1cSThomas Renninger { 338ac551828SJean Delvare sprintf(alias, "acpi*:%s:*", id->id); 33929b71a1cSThomas Renninger return 1; 34029b71a1cSThomas Renninger } 34129b71a1cSThomas Renninger 3421da177e4SLinus Torvalds /* looks like: "pnp:dD" */ 3431da177e4SLinus Torvalds static int do_pnp_entry(const char *filename, 3441da177e4SLinus Torvalds struct pnp_device_id *id, char *alias) 3451da177e4SLinus Torvalds { 346ac551828SJean Delvare sprintf(alias, "pnp:d%s*", id->id); 3471da177e4SLinus Torvalds return 1; 3481da177e4SLinus Torvalds } 3491da177e4SLinus Torvalds 3500c81eed4SKay Sievers /* looks like: "pnp:dD" for every device of the card */ 3510c81eed4SKay Sievers static void do_pnp_card_entries(void *symval, unsigned long size, 3520c81eed4SKay Sievers struct module *mod) 3531da177e4SLinus Torvalds { 3540c81eed4SKay Sievers const unsigned long id_size = sizeof(struct pnp_card_device_id); 3550c81eed4SKay Sievers const unsigned int count = (size / id_size)-1; 3560c81eed4SKay Sievers const struct pnp_card_device_id *cards = symval; 3570c81eed4SKay Sievers unsigned int i; 3581da177e4SLinus Torvalds 3590c81eed4SKay Sievers device_id_check(mod->name, "pnp", size, id_size, symval); 3600c81eed4SKay Sievers 3610c81eed4SKay Sievers for (i = 0; i < count; i++) { 3620c81eed4SKay Sievers unsigned int j; 3630c81eed4SKay Sievers const struct pnp_card_device_id *card = &cards[i]; 3640c81eed4SKay Sievers 3650c81eed4SKay Sievers for (j = 0; j < PNP_MAX_DEVICES; j++) { 3660c81eed4SKay Sievers const char *id = (char *)card->devs[j].id; 3670c81eed4SKay Sievers int i2, j2; 3680c81eed4SKay Sievers int dup = 0; 3690c81eed4SKay Sievers 3700c81eed4SKay Sievers if (!id[0]) 3711da177e4SLinus Torvalds break; 3720c81eed4SKay Sievers 3730c81eed4SKay Sievers /* find duplicate, already added value */ 3740c81eed4SKay Sievers for (i2 = 0; i2 < i && !dup; i2++) { 3750c81eed4SKay Sievers const struct pnp_card_device_id *card2 = &cards[i2]; 3760c81eed4SKay Sievers 3770c81eed4SKay Sievers for (j2 = 0; j2 < PNP_MAX_DEVICES; j2++) { 3780c81eed4SKay Sievers const char *id2 = (char *)card2->devs[j2].id; 3790c81eed4SKay Sievers 3800c81eed4SKay Sievers if (!id2[0]) 3810c81eed4SKay Sievers break; 3820c81eed4SKay Sievers 3830c81eed4SKay Sievers if (!strcmp(id, id2)) { 3840c81eed4SKay Sievers dup = 1; 3850c81eed4SKay Sievers break; 3861da177e4SLinus Torvalds } 3870c81eed4SKay Sievers } 3880c81eed4SKay Sievers } 3890c81eed4SKay Sievers 3900c81eed4SKay Sievers /* add an individual alias for every device entry */ 3910c81eed4SKay Sievers if (!dup) 3920c81eed4SKay Sievers buf_printf(&mod->dev_table_buf, 3930c81eed4SKay Sievers "MODULE_ALIAS(\"pnp:d%s*\");\n", id); 3940c81eed4SKay Sievers } 3950c81eed4SKay Sievers } 3961da177e4SLinus Torvalds } 3971da177e4SLinus Torvalds 39890829cfeSDominik Brodowski /* Looks like: pcmcia:mNcNfNfnNpfnNvaNvbNvcNvdN. */ 39990829cfeSDominik Brodowski static int do_pcmcia_entry(const char *filename, 40090829cfeSDominik Brodowski struct pcmcia_device_id *id, char *alias) 40190829cfeSDominik Brodowski { 40290829cfeSDominik Brodowski unsigned int i; 40390829cfeSDominik Brodowski 4044fb7edceSKars de Jong id->match_flags = TO_NATIVE(id->match_flags); 40590829cfeSDominik Brodowski id->manf_id = TO_NATIVE(id->manf_id); 40690829cfeSDominik Brodowski id->card_id = TO_NATIVE(id->card_id); 40790829cfeSDominik Brodowski id->func_id = TO_NATIVE(id->func_id); 40890829cfeSDominik Brodowski id->function = TO_NATIVE(id->function); 40990829cfeSDominik Brodowski id->device_no = TO_NATIVE(id->device_no); 4104fb7edceSKars de Jong 41190829cfeSDominik Brodowski for (i=0; i<4; i++) { 41290829cfeSDominik Brodowski id->prod_id_hash[i] = TO_NATIVE(id->prod_id_hash[i]); 41390829cfeSDominik Brodowski } 41490829cfeSDominik Brodowski 41590829cfeSDominik Brodowski strcpy(alias, "pcmcia:"); 41690829cfeSDominik Brodowski ADD(alias, "m", id->match_flags & PCMCIA_DEV_ID_MATCH_MANF_ID, 41790829cfeSDominik Brodowski id->manf_id); 41890829cfeSDominik Brodowski ADD(alias, "c", id->match_flags & PCMCIA_DEV_ID_MATCH_CARD_ID, 41990829cfeSDominik Brodowski id->card_id); 42090829cfeSDominik Brodowski ADD(alias, "f", id->match_flags & PCMCIA_DEV_ID_MATCH_FUNC_ID, 42190829cfeSDominik Brodowski id->func_id); 42290829cfeSDominik Brodowski ADD(alias, "fn", id->match_flags & PCMCIA_DEV_ID_MATCH_FUNCTION, 42390829cfeSDominik Brodowski id->function); 42490829cfeSDominik Brodowski ADD(alias, "pfn", id->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO, 42590829cfeSDominik Brodowski id->device_no); 42690829cfeSDominik Brodowski ADD(alias, "pa", id->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID1, id->prod_id_hash[0]); 42790829cfeSDominik Brodowski ADD(alias, "pb", id->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID2, id->prod_id_hash[1]); 42890829cfeSDominik Brodowski ADD(alias, "pc", id->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID3, id->prod_id_hash[2]); 42990829cfeSDominik Brodowski ADD(alias, "pd", id->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID4, id->prod_id_hash[3]); 43090829cfeSDominik Brodowski 431ac551828SJean Delvare add_wildcard(alias); 43290829cfeSDominik Brodowski return 1; 43390829cfeSDominik Brodowski } 43490829cfeSDominik Brodowski 43590829cfeSDominik Brodowski 43690829cfeSDominik Brodowski 4375e655772SJeff Mahoney static int do_of_entry (const char *filename, struct of_device_id *of, char *alias) 4385e655772SJeff Mahoney { 439d1ab4235SSylvain Munaut int len; 4405e655772SJeff Mahoney char *tmp; 441d1ab4235SSylvain Munaut len = sprintf (alias, "of:N%sT%s", 4425e655772SJeff Mahoney of->name[0] ? of->name : "*", 443d1ab4235SSylvain Munaut of->type[0] ? of->type : "*"); 444d1ab4235SSylvain Munaut 445d1ab4235SSylvain Munaut if (of->compatible[0]) 446d1ab4235SSylvain Munaut sprintf (&alias[len], "%sC%s", 447d1ab4235SSylvain Munaut of->type[0] ? "*" : "", 448d1ab4235SSylvain Munaut of->compatible); 4495e655772SJeff Mahoney 4505e655772SJeff Mahoney /* Replace all whitespace with underscores */ 4515e655772SJeff Mahoney for (tmp = alias; tmp && *tmp; tmp++) 4525e655772SJeff Mahoney if (isspace (*tmp)) 4535e655772SJeff Mahoney *tmp = '_'; 4545e655772SJeff Mahoney 455ac551828SJean Delvare add_wildcard(alias); 4565e655772SJeff Mahoney return 1; 4575e655772SJeff Mahoney } 4585e655772SJeff Mahoney 459fb120da6SStephen Rothwell static int do_vio_entry(const char *filename, struct vio_device_id *vio, 460fb120da6SStephen Rothwell char *alias) 461fb120da6SStephen Rothwell { 462fb120da6SStephen Rothwell char *tmp; 463fb120da6SStephen Rothwell 464fb120da6SStephen Rothwell sprintf(alias, "vio:T%sS%s", vio->type[0] ? vio->type : "*", 465fb120da6SStephen Rothwell vio->compat[0] ? vio->compat : "*"); 466fb120da6SStephen Rothwell 467fb120da6SStephen Rothwell /* Replace all whitespace with underscores */ 468fb120da6SStephen Rothwell for (tmp = alias; tmp && *tmp; tmp++) 469fb120da6SStephen Rothwell if (isspace (*tmp)) 470fb120da6SStephen Rothwell *tmp = '_'; 471fb120da6SStephen Rothwell 472ac551828SJean Delvare add_wildcard(alias); 473fb120da6SStephen Rothwell return 1; 474fb120da6SStephen Rothwell } 475fb120da6SStephen Rothwell 4761d8f430cSRusty Russell #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) 4771d8f430cSRusty Russell 4781d8f430cSRusty Russell static void do_input(char *alias, 4791d8f430cSRusty Russell kernel_ulong_t *arr, unsigned int min, unsigned int max) 4801d8f430cSRusty Russell { 4811d8f430cSRusty Russell unsigned int i; 482ddc5d341SDmitry Torokhov 483ddc5d341SDmitry Torokhov for (i = min; i < max; i++) 484e0e92632SHans de Goede if (arr[i / BITS_PER_LONG] & (1L << (i%BITS_PER_LONG))) 4851d8f430cSRusty Russell sprintf(alias + strlen(alias), "%X,*", i); 4861d8f430cSRusty Russell } 4871d8f430cSRusty Russell 4881d8f430cSRusty Russell /* input:b0v0p0e0-eXkXrXaXmXlXsXfXwX where X is comma-separated %02X. */ 4891d8f430cSRusty Russell static int do_input_entry(const char *filename, struct input_device_id *id, 4901d8f430cSRusty Russell char *alias) 4911d8f430cSRusty Russell { 4921d8f430cSRusty Russell sprintf(alias, "input:"); 4931d8f430cSRusty Russell 494ddc5d341SDmitry Torokhov ADD(alias, "b", id->flags & INPUT_DEVICE_ID_MATCH_BUS, id->bustype); 495ddc5d341SDmitry Torokhov ADD(alias, "v", id->flags & INPUT_DEVICE_ID_MATCH_VENDOR, id->vendor); 496ddc5d341SDmitry Torokhov ADD(alias, "p", id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT, id->product); 497ddc5d341SDmitry Torokhov ADD(alias, "e", id->flags & INPUT_DEVICE_ID_MATCH_VERSION, id->version); 4981d8f430cSRusty Russell 4991d8f430cSRusty Russell sprintf(alias + strlen(alias), "-e*"); 5001d8f430cSRusty Russell if (id->flags & INPUT_DEVICE_ID_MATCH_EVBIT) 501dc24f0e7SSam Ravnborg do_input(alias, id->evbit, 0, INPUT_DEVICE_ID_EV_MAX); 5021d8f430cSRusty Russell sprintf(alias + strlen(alias), "k*"); 5031d8f430cSRusty Russell if (id->flags & INPUT_DEVICE_ID_MATCH_KEYBIT) 504dc24f0e7SSam Ravnborg do_input(alias, id->keybit, 505dc24f0e7SSam Ravnborg INPUT_DEVICE_ID_KEY_MIN_INTERESTING, 506dc24f0e7SSam Ravnborg INPUT_DEVICE_ID_KEY_MAX); 5071d8f430cSRusty Russell sprintf(alias + strlen(alias), "r*"); 5081d8f430cSRusty Russell if (id->flags & INPUT_DEVICE_ID_MATCH_RELBIT) 509dc24f0e7SSam Ravnborg do_input(alias, id->relbit, 0, INPUT_DEVICE_ID_REL_MAX); 5101d8f430cSRusty Russell sprintf(alias + strlen(alias), "a*"); 5111d8f430cSRusty Russell if (id->flags & INPUT_DEVICE_ID_MATCH_ABSBIT) 512dc24f0e7SSam Ravnborg do_input(alias, id->absbit, 0, INPUT_DEVICE_ID_ABS_MAX); 5131d8f430cSRusty Russell sprintf(alias + strlen(alias), "m*"); 5141d8f430cSRusty Russell if (id->flags & INPUT_DEVICE_ID_MATCH_MSCIT) 515dc24f0e7SSam Ravnborg do_input(alias, id->mscbit, 0, INPUT_DEVICE_ID_MSC_MAX); 5161d8f430cSRusty Russell sprintf(alias + strlen(alias), "l*"); 5171d8f430cSRusty Russell if (id->flags & INPUT_DEVICE_ID_MATCH_LEDBIT) 518dc24f0e7SSam Ravnborg do_input(alias, id->ledbit, 0, INPUT_DEVICE_ID_LED_MAX); 5191d8f430cSRusty Russell sprintf(alias + strlen(alias), "s*"); 5201d8f430cSRusty Russell if (id->flags & INPUT_DEVICE_ID_MATCH_SNDBIT) 521dc24f0e7SSam Ravnborg do_input(alias, id->sndbit, 0, INPUT_DEVICE_ID_SND_MAX); 5221d8f430cSRusty Russell sprintf(alias + strlen(alias), "f*"); 5231d8f430cSRusty Russell if (id->flags & INPUT_DEVICE_ID_MATCH_FFBIT) 524dc24f0e7SSam Ravnborg do_input(alias, id->ffbit, 0, INPUT_DEVICE_ID_FF_MAX); 5251d8f430cSRusty Russell sprintf(alias + strlen(alias), "w*"); 5261d8f430cSRusty Russell if (id->flags & INPUT_DEVICE_ID_MATCH_SWBIT) 527dc24f0e7SSam Ravnborg do_input(alias, id->swbit, 0, INPUT_DEVICE_ID_SW_MAX); 5281d8f430cSRusty Russell return 1; 5291d8f430cSRusty Russell } 5301d8f430cSRusty Russell 53107563c71SMichael Tokarev static int do_eisa_entry(const char *filename, struct eisa_device_id *eisa, 53207563c71SMichael Tokarev char *alias) 53307563c71SMichael Tokarev { 53407563c71SMichael Tokarev if (eisa->sig[0]) 53507563c71SMichael Tokarev sprintf(alias, EISA_DEVICE_MODALIAS_FMT "*", eisa->sig); 536ac551828SJean Delvare else 537ac551828SJean Delvare strcat(alias, "*"); 53807563c71SMichael Tokarev return 1; 53907563c71SMichael Tokarev } 54007563c71SMichael Tokarev 541f3cf2673SKyle McMartin /* Looks like: parisc:tNhvNrevNsvN */ 542f3cf2673SKyle McMartin static int do_parisc_entry(const char *filename, struct parisc_device_id *id, 543f3cf2673SKyle McMartin char *alias) 544f3cf2673SKyle McMartin { 545f3cf2673SKyle McMartin id->hw_type = TO_NATIVE(id->hw_type); 546f3cf2673SKyle McMartin id->hversion = TO_NATIVE(id->hversion); 547f3cf2673SKyle McMartin id->hversion_rev = TO_NATIVE(id->hversion_rev); 548f3cf2673SKyle McMartin id->sversion = TO_NATIVE(id->sversion); 549f3cf2673SKyle McMartin 550f3cf2673SKyle McMartin strcpy(alias, "parisc:"); 551f354ef8aSKyle McMartin ADD(alias, "t", id->hw_type != PA_HWTYPE_ANY_ID, id->hw_type); 552f354ef8aSKyle McMartin ADD(alias, "hv", id->hversion != PA_HVERSION_ANY_ID, id->hversion); 553f354ef8aSKyle McMartin ADD(alias, "rev", id->hversion_rev != PA_HVERSION_REV_ANY_ID, id->hversion_rev); 554f354ef8aSKyle McMartin ADD(alias, "sv", id->sversion != PA_SVERSION_ANY_ID, id->sversion); 555f3cf2673SKyle McMartin 556ac551828SJean Delvare add_wildcard(alias); 557f3cf2673SKyle McMartin return 1; 558f3cf2673SKyle McMartin } 559f3cf2673SKyle McMartin 560d59b66c7SPierre Ossman /* Looks like: sdio:cNvNdN. */ 561d59b66c7SPierre Ossman static int do_sdio_entry(const char *filename, 562d59b66c7SPierre Ossman struct sdio_device_id *id, char *alias) 563d59b66c7SPierre Ossman { 564d59b66c7SPierre Ossman id->class = TO_NATIVE(id->class); 565d59b66c7SPierre Ossman id->vendor = TO_NATIVE(id->vendor); 566d59b66c7SPierre Ossman id->device = TO_NATIVE(id->device); 567d59b66c7SPierre Ossman 568d59b66c7SPierre Ossman strcpy(alias, "sdio:"); 569d59b66c7SPierre Ossman ADD(alias, "c", id->class != (__u8)SDIO_ANY_ID, id->class); 570d59b66c7SPierre Ossman ADD(alias, "v", id->vendor != (__u16)SDIO_ANY_ID, id->vendor); 571d59b66c7SPierre Ossman ADD(alias, "d", id->device != (__u16)SDIO_ANY_ID, id->device); 572ac551828SJean Delvare add_wildcard(alias); 573038a5008SLinus Torvalds return 1; 574038a5008SLinus Torvalds } 575d59b66c7SPierre Ossman 57661e115a5SMichael Buesch /* Looks like: ssb:vNidNrevN. */ 57761e115a5SMichael Buesch static int do_ssb_entry(const char *filename, 57861e115a5SMichael Buesch struct ssb_device_id *id, char *alias) 57961e115a5SMichael Buesch { 58061e115a5SMichael Buesch id->vendor = TO_NATIVE(id->vendor); 58161e115a5SMichael Buesch id->coreid = TO_NATIVE(id->coreid); 58261e115a5SMichael Buesch id->revision = TO_NATIVE(id->revision); 58361e115a5SMichael Buesch 58461e115a5SMichael Buesch strcpy(alias, "ssb:"); 58561e115a5SMichael Buesch ADD(alias, "v", id->vendor != SSB_ANY_VENDOR, id->vendor); 58661e115a5SMichael Buesch ADD(alias, "id", id->coreid != SSB_ANY_ID, id->coreid); 58761e115a5SMichael Buesch ADD(alias, "rev", id->revision != SSB_ANY_REV, id->revision); 588ac551828SJean Delvare add_wildcard(alias); 589d59b66c7SPierre Ossman return 1; 590d59b66c7SPierre Ossman } 591d59b66c7SPierre Ossman 592b01d9f28SRusty Russell /* Looks like: virtio:dNvN */ 593b01d9f28SRusty Russell static int do_virtio_entry(const char *filename, struct virtio_device_id *id, 594b01d9f28SRusty Russell char *alias) 595b01d9f28SRusty Russell { 596b01d9f28SRusty Russell id->device = TO_NATIVE(id->device); 597b01d9f28SRusty Russell id->vendor = TO_NATIVE(id->vendor); 598b01d9f28SRusty Russell 599b01d9f28SRusty Russell strcpy(alias, "virtio:"); 600b01d9f28SRusty Russell ADD(alias, "d", 1, id->device); 601b01d9f28SRusty Russell ADD(alias, "v", id->vendor != VIRTIO_DEV_ANY_ID, id->vendor); 602b01d9f28SRusty Russell 603ac551828SJean Delvare add_wildcard(alias); 604b01d9f28SRusty Russell return 1; 605b01d9f28SRusty Russell } 606b01d9f28SRusty Russell 607d2653e92SJean Delvare /* Looks like: i2c:S */ 608d2653e92SJean Delvare static int do_i2c_entry(const char *filename, struct i2c_device_id *id, 609d2653e92SJean Delvare char *alias) 610d2653e92SJean Delvare { 611d2653e92SJean Delvare sprintf(alias, I2C_MODULE_PREFIX "%s", id->name); 612d2653e92SJean Delvare 613d2653e92SJean Delvare return 1; 614d2653e92SJean Delvare } 615d2653e92SJean Delvare 6161da177e4SLinus Torvalds /* Ignore any prefix, eg. v850 prepends _ */ 6171da177e4SLinus Torvalds static inline int sym_is(const char *symbol, const char *name) 6181da177e4SLinus Torvalds { 6191da177e4SLinus Torvalds const char *match; 6201da177e4SLinus Torvalds 6211da177e4SLinus Torvalds match = strstr(symbol, name); 6221da177e4SLinus Torvalds if (!match) 6231da177e4SLinus Torvalds return 0; 6241da177e4SLinus Torvalds return match[strlen(symbol)] == '\0'; 6251da177e4SLinus Torvalds } 6261da177e4SLinus Torvalds 6271da177e4SLinus Torvalds static void do_table(void *symval, unsigned long size, 6281da177e4SLinus Torvalds unsigned long id_size, 629fb33d816SSam Ravnborg const char *device_id, 6301da177e4SLinus Torvalds void *function, 6311da177e4SLinus Torvalds struct module *mod) 6321da177e4SLinus Torvalds { 6331da177e4SLinus Torvalds unsigned int i; 6341da177e4SLinus Torvalds char alias[500]; 6351da177e4SLinus Torvalds int (*do_entry)(const char *, void *entry, char *alias) = function; 6361da177e4SLinus Torvalds 637e0049825SKees Cook device_id_check(mod->name, device_id, size, id_size, symval); 6381da177e4SLinus Torvalds /* Leave last one: it's the terminator. */ 6391da177e4SLinus Torvalds size -= id_size; 6401da177e4SLinus Torvalds 6411da177e4SLinus Torvalds for (i = 0; i < size; i += id_size) { 6421da177e4SLinus Torvalds if (do_entry(mod->name, symval+i, alias)) { 6431da177e4SLinus Torvalds buf_printf(&mod->dev_table_buf, 6441da177e4SLinus Torvalds "MODULE_ALIAS(\"%s\");\n", alias); 6451da177e4SLinus Torvalds } 6461da177e4SLinus Torvalds } 6471da177e4SLinus Torvalds } 6481da177e4SLinus Torvalds 6491da177e4SLinus Torvalds /* Create MODULE_ALIAS() statements. 6501da177e4SLinus Torvalds * At this time, we cannot write the actual output C source yet, 6511da177e4SLinus Torvalds * so we write into the mod->dev_table_buf buffer. */ 6521da177e4SLinus Torvalds void handle_moddevtable(struct module *mod, struct elf_info *info, 6531da177e4SLinus Torvalds Elf_Sym *sym, const char *symname) 6541da177e4SLinus Torvalds { 6551da177e4SLinus Torvalds void *symval; 656e0049825SKees Cook char *zeros = NULL; 6571da177e4SLinus Torvalds 6581da177e4SLinus Torvalds /* We're looking for a section relative symbol */ 6591da177e4SLinus Torvalds if (!sym->st_shndx || sym->st_shndx >= info->hdr->e_shnum) 6601da177e4SLinus Torvalds return; 6611da177e4SLinus Torvalds 662e0049825SKees Cook /* Handle all-NULL symbols allocated into .bss */ 663e0049825SKees Cook if (info->sechdrs[sym->st_shndx].sh_type & SHT_NOBITS) { 664e0049825SKees Cook zeros = calloc(1, sym->st_size); 665e0049825SKees Cook symval = zeros; 666e0049825SKees Cook } else { 6671da177e4SLinus Torvalds symval = (void *)info->hdr 6681da177e4SLinus Torvalds + info->sechdrs[sym->st_shndx].sh_offset 6691da177e4SLinus Torvalds + sym->st_value; 670e0049825SKees Cook } 6711da177e4SLinus Torvalds 6721da177e4SLinus Torvalds if (sym_is(symname, "__mod_pci_device_table")) 673fb33d816SSam Ravnborg do_table(symval, sym->st_size, 674fb33d816SSam Ravnborg sizeof(struct pci_device_id), "pci", 6751da177e4SLinus Torvalds do_pci_entry, mod); 6761da177e4SLinus Torvalds else if (sym_is(symname, "__mod_usb_device_table")) 677b19dcd93SRoman Kagan /* special case to handle bcdDevice ranges */ 678b19dcd93SRoman Kagan do_usb_table(symval, sym->st_size, mod); 6791da177e4SLinus Torvalds else if (sym_is(symname, "__mod_ieee1394_device_table")) 680fb33d816SSam Ravnborg do_table(symval, sym->st_size, 681fb33d816SSam Ravnborg sizeof(struct ieee1394_device_id), "ieee1394", 6821da177e4SLinus Torvalds do_ieee1394_entry, mod); 6831da177e4SLinus Torvalds else if (sym_is(symname, "__mod_ccw_device_table")) 684fb33d816SSam Ravnborg do_table(symval, sym->st_size, 685fb33d816SSam Ravnborg sizeof(struct ccw_device_id), "ccw", 6861da177e4SLinus Torvalds do_ccw_entry, mod); 6871534c382SMartin Schwidefsky else if (sym_is(symname, "__mod_ap_device_table")) 6881534c382SMartin Schwidefsky do_table(symval, sym->st_size, 6891534c382SMartin Schwidefsky sizeof(struct ap_device_id), "ap", 6901534c382SMartin Schwidefsky do_ap_entry, mod); 691*7e9db9eaSCornelia Huck else if (sym_is(symname, "__mod_css_device_table")) 692*7e9db9eaSCornelia Huck do_table(symval, sym->st_size, 693*7e9db9eaSCornelia Huck sizeof(struct css_device_id), "css", 694*7e9db9eaSCornelia Huck do_css_entry, mod); 6951da177e4SLinus Torvalds else if (sym_is(symname, "__mod_serio_device_table")) 696fb33d816SSam Ravnborg do_table(symval, sym->st_size, 697fb33d816SSam Ravnborg sizeof(struct serio_device_id), "serio", 6981da177e4SLinus Torvalds do_serio_entry, mod); 69929b71a1cSThomas Renninger else if (sym_is(symname, "__mod_acpi_device_table")) 70029b71a1cSThomas Renninger do_table(symval, sym->st_size, 70129b71a1cSThomas Renninger sizeof(struct acpi_device_id), "acpi", 70229b71a1cSThomas Renninger do_acpi_entry, mod); 7031da177e4SLinus Torvalds else if (sym_is(symname, "__mod_pnp_device_table")) 704fb33d816SSam Ravnborg do_table(symval, sym->st_size, 705fb33d816SSam Ravnborg sizeof(struct pnp_device_id), "pnp", 7061da177e4SLinus Torvalds do_pnp_entry, mod); 7071da177e4SLinus Torvalds else if (sym_is(symname, "__mod_pnp_card_device_table")) 7080c81eed4SKay Sievers do_pnp_card_entries(symval, sym->st_size, mod); 70990829cfeSDominik Brodowski else if (sym_is(symname, "__mod_pcmcia_device_table")) 710fb33d816SSam Ravnborg do_table(symval, sym->st_size, 711fb33d816SSam Ravnborg sizeof(struct pcmcia_device_id), "pcmcia", 71290829cfeSDominik Brodowski do_pcmcia_entry, mod); 7135e655772SJeff Mahoney else if (sym_is(symname, "__mod_of_device_table")) 714fb33d816SSam Ravnborg do_table(symval, sym->st_size, 715fb33d816SSam Ravnborg sizeof(struct of_device_id), "of", 7165e655772SJeff Mahoney do_of_entry, mod); 717fb120da6SStephen Rothwell else if (sym_is(symname, "__mod_vio_device_table")) 718fb33d816SSam Ravnborg do_table(symval, sym->st_size, 719fb33d816SSam Ravnborg sizeof(struct vio_device_id), "vio", 720fb120da6SStephen Rothwell do_vio_entry, mod); 7211d8f430cSRusty Russell else if (sym_is(symname, "__mod_input_device_table")) 722fb33d816SSam Ravnborg do_table(symval, sym->st_size, 723fb33d816SSam Ravnborg sizeof(struct input_device_id), "input", 7241d8f430cSRusty Russell do_input_entry, mod); 72507563c71SMichael Tokarev else if (sym_is(symname, "__mod_eisa_device_table")) 72607563c71SMichael Tokarev do_table(symval, sym->st_size, 72707563c71SMichael Tokarev sizeof(struct eisa_device_id), "eisa", 72807563c71SMichael Tokarev do_eisa_entry, mod); 729f3cf2673SKyle McMartin else if (sym_is(symname, "__mod_parisc_device_table")) 730f3cf2673SKyle McMartin do_table(symval, sym->st_size, 731f3cf2673SKyle McMartin sizeof(struct parisc_device_id), "parisc", 732f3cf2673SKyle McMartin do_parisc_entry, mod); 733d59b66c7SPierre Ossman else if (sym_is(symname, "__mod_sdio_device_table")) 734d59b66c7SPierre Ossman do_table(symval, sym->st_size, 735d59b66c7SPierre Ossman sizeof(struct sdio_device_id), "sdio", 736d59b66c7SPierre Ossman do_sdio_entry, mod); 73761e115a5SMichael Buesch else if (sym_is(symname, "__mod_ssb_device_table")) 73861e115a5SMichael Buesch do_table(symval, sym->st_size, 73961e115a5SMichael Buesch sizeof(struct ssb_device_id), "ssb", 74061e115a5SMichael Buesch do_ssb_entry, mod); 741b01d9f28SRusty Russell else if (sym_is(symname, "__mod_virtio_device_table")) 742b01d9f28SRusty Russell do_table(symval, sym->st_size, 743b01d9f28SRusty Russell sizeof(struct virtio_device_id), "virtio", 744b01d9f28SRusty Russell do_virtio_entry, mod); 745d2653e92SJean Delvare else if (sym_is(symname, "__mod_i2c_device_table")) 746d2653e92SJean Delvare do_table(symval, sym->st_size, 747d2653e92SJean Delvare sizeof(struct i2c_device_id), "i2c", 748d2653e92SJean Delvare do_i2c_entry, mod); 749e0049825SKees Cook free(zeros); 7501da177e4SLinus Torvalds } 7511da177e4SLinus Torvalds 7521da177e4SLinus Torvalds /* Now add out buffered information to the generated C source */ 7531da177e4SLinus Torvalds void add_moddevtable(struct buffer *buf, struct module *mod) 7541da177e4SLinus Torvalds { 7551da177e4SLinus Torvalds buf_printf(buf, "\n"); 7561da177e4SLinus Torvalds buf_write(buf, mod->dev_table_buf.p, mod->dev_table_buf.pos); 7571da177e4SLinus Torvalds free(mod->dev_table_buf.p); 7581da177e4SLinus Torvalds } 759