Merge branch 'akpm' (final batch from Andrew)
authorLinus Torvalds <torvalds@linux-foundation.org>
Thu, 28 Feb 2013 04:58:09 +0000 (20:58 -0800)
committerLinus Torvalds <torvalds@linux-foundation.org>
Thu, 28 Feb 2013 04:58:09 +0000 (20:58 -0800)
Merge third patch-bumb from Andrew Morton:
 "This wraps me up for -rc1.
   - Lots of misc stuff and things which were deferred/missed from
     patchbombings 1 & 2.
   - ocfs2 things
   - lib/scatterlist
   - hfsplus
   - fatfs
   - documentation
   - signals
   - procfs
   - lockdep
   - coredump
   - seqfile core
   - kexec
   - Tejun's large IDR tree reworkings
   - ipmi
   - partitions
   - nbd
   - random() things
   - kfifo
   - tools/testing/selftests updates
   - Sasha's large and pointless hlist cleanup"

* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (163 commits)
  hlist: drop the node parameter from iterators
  kcmp: make it depend on CHECKPOINT_RESTORE
  selftests: add a simple doc
  tools/testing/selftests/Makefile: rearrange targets
  selftests/efivarfs: add create-read test
  selftests/efivarfs: add empty file creation test
  selftests: add tests for efivarfs
  kfifo: fix kfifo_alloc() and kfifo_init()
  kfifo: move kfifo.c from kernel/ to lib/
  arch Kconfig: centralise CONFIG_ARCH_NO_VIRT_TO_BUS
  w1: add support for DS2413 Dual Channel Addressable Switch
  memstick: move the dereference below the NULL test
  drivers/pps/clients/pps-gpio.c: use devm_kzalloc
  Documentation/DMA-API-HOWTO.txt: fix typo
  include/linux/eventfd.h: fix incorrect filename is a comment
  mtd: mtd_stresstest: use prandom_bytes()
  mtd: mtd_subpagetest: convert to use prandom library
  mtd: mtd_speedtest: use prandom_bytes
  mtd: mtd_pagetest: convert to use prandom library
  mtd: mtd_oobtest: convert to use prandom library
  ...

59 files changed:
Documentation/coccinelle.txt
Documentation/kbuild/kconfig-language.txt
Documentation/kbuild/kconfig.txt
Documentation/kernel-parameters.txt
Makefile
arch/x86/boot/compressed/eboot.c
arch/x86/include/asm/efi.h
arch/x86/kernel/head.c
arch/x86/kernel/head_64.S
arch/x86/kernel/setup.c
arch/x86/platform/efi/efi.c
drivers/acpi/Kconfig
drivers/firmware/efivars.c
fs/ext4/extents_status.h
include/linux/mod_devicetable.h
kernel/Makefile
kernel/timeconst.bc [new file with mode: 0644]
kernel/timeconst.pl [deleted file]
scripts/Makefile.headersinst
scripts/Makefile.modpost
scripts/coccicheck
scripts/coccinelle/misc/memcpy-assign.cocci [new file with mode: 0644]
scripts/coccinelle/misc/orplus.cocci [new file with mode: 0644]
scripts/coccinelle/misc/semicolon.cocci [new file with mode: 0644]
scripts/depmod.sh
scripts/kconfig/Makefile
scripts/kconfig/conf.c
scripts/kconfig/expr.c
scripts/kconfig/gconf.c
scripts/kconfig/lkc.h
scripts/kconfig/lxdialog/check-lxdialog.sh
scripts/kconfig/lxdialog/dialog.h
scripts/kconfig/lxdialog/inputbox.c
scripts/kconfig/lxdialog/menubox.c
scripts/kconfig/mconf.c
scripts/kconfig/menu.c
scripts/kconfig/merge_config.sh
scripts/kconfig/nconf.c
scripts/kconfig/nconf.gui.c
scripts/kconfig/qconf.cc
scripts/kconfig/symbol.c
scripts/kconfig/util.c
scripts/kconfig/zconf.l
scripts/kconfig/zconf.lex.c_shipped
scripts/link-vmlinux.sh
scripts/mod/.gitignore
scripts/mod/Makefile
scripts/mod/devicetable-offsets.c [new file with mode: 0644]
scripts/mod/file2alias.c
scripts/mod/modpost.c
scripts/package/mkspec
scripts/setlocalversion
scripts/tags.sh
sound/pci/bt87x.c
sound/pci/emu10k1/emu10k1_main.c
sound/pci/emu10k1/emupcm.c
sound/pci/hda/patch_hdmi.c
sound/pci/hda/patch_realtek.c
sound/pci/ice1712/revo.c

index cf44eb6..dffa2d6 100644 (file)
@@ -87,6 +87,10 @@ As any static code analyzer, Coccinelle produces false
 positives. Thus, reports must be carefully checked, and patches
 reviewed.
 
+To enable verbose messages set the V= variable, for example:
+
+   make coccicheck MODE=report V=1
+
 
  Using Coccinelle with a single semantic patch
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
index a686f9c..c858f84 100644 (file)
@@ -388,26 +388,3 @@ config FOO
        depends on BAR && m
 
 limits FOO to module (=m) or disabled (=n).
-
-Kconfig symbol existence
-~~~~~~~~~~~~~~~~~~~~~~~~
-The following two methods produce the same kconfig symbol dependencies
-but differ greatly in kconfig symbol existence (production) in the
-generated config file.
-
-case 1:
-
-config FOO
-       tristate "about foo"
-       depends on BAR
-
-vs. case 2:
-
-if BAR
-config FOO
-       tristate "about foo"
-endif
-
-In case 1, the symbol FOO will always exist in the config file (given
-no other dependencies).  In case 2, the symbol FOO will only exist in
-the config file if BAR is enabled.
index a09f1a6..b8b77bb 100644 (file)
@@ -46,6 +46,12 @@ KCONFIG_OVERWRITECONFIG
 If you set KCONFIG_OVERWRITECONFIG in the environment, Kconfig will not
 break symlinks when .config is a symlink to somewhere else.
 
+CONFIG_
+--------------------------------------------------
+If you set CONFIG_ in the environment, Kconfig will prefix all symbols
+with its value when saving the configuration, instead of using the default,
+"CONFIG_".
+
 ______________________________________________________________________
 Environment variables for '{allyes/allmod/allno/rand}config'
 
index 1da9465..e567af3 100644 (file)
@@ -564,6 +564,8 @@ bytes respectively. Such letter suffixes can also be entirely omitted.
                        UART at the specified I/O port or MMIO address,
                        switching to the matching ttyS device later.  The
                        options are the same as for ttyS, above.
+               hvc<n>  Use the hypervisor console device <n>. This is for
+                       both Xen and PowerPC hypervisors.
 
                 If the device connected to the port is not a TTY but a braille
                 device, prepend "brl," before the device type, for instance
@@ -757,6 +759,7 @@ bytes respectively. Such letter suffixes can also be entirely omitted.
 
        earlyprintk=    [X86,SH,BLACKFIN]
                        earlyprintk=vga
+                       earlyprintk=xen
                        earlyprintk=serial[,ttySn[,baudrate]]
                        earlyprintk=ttySn[,baudrate]
                        earlyprintk=dbgp[debugController#]
@@ -774,6 +777,8 @@ bytes respectively. Such letter suffixes can also be entirely omitted.
                        The VGA output is eventually overwritten by the real
                        console.
 
+                       The xen output can only be used by Xen PV guests.
+
        ekgdboc=        [X86,KGDB] Allow early kernel console debugging
                        ekgdboc=kbd
 
index 2309b43..473beb1 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -192,7 +192,6 @@ SUBARCH := $(shell uname -m | sed -e s/i.86/x86/ -e s/x86_64/x86/ \
 # "make" in the configured kernel build directory always uses that.
 # Default value for CROSS_COMPILE is not to prefix executables
 # Note: Some architectures assign CROSS_COMPILE in their arch/*/Makefile
-export KBUILD_BUILDHOST := $(SUBARCH)
 ARCH           ?= $(SUBARCH)
 CROSS_COMPILE  ?= $(CONFIG_CROSS_COMPILE:"%"=%)
 
@@ -620,7 +619,8 @@ KBUILD_AFLAGS       += -gdwarf-2
 endif
 
 ifdef CONFIG_DEBUG_INFO_REDUCED
-KBUILD_CFLAGS  += $(call cc-option, -femit-struct-debug-baseonly)
+KBUILD_CFLAGS  += $(call cc-option, -femit-struct-debug-baseonly) \
+                  $(call cc-option,-fno-var-tracking)
 endif
 
 ifdef CONFIG_FUNCTION_TRACER
@@ -1398,7 +1398,7 @@ quiet_cmd_rmfiles = $(if $(wildcard $(rm-files)),CLEAN   $(wildcard $(rm-files))
 # Run depmod only if we have System.map and depmod is executable
 quiet_cmd_depmod = DEPMOD  $(KERNELRELEASE)
       cmd_depmod = $(CONFIG_SHELL) $(srctree)/scripts/depmod.sh $(DEPMOD) \
-                   $(KERNELRELEASE)
+                   $(KERNELRELEASE) "$(patsubst "%",%,$(CONFIG_SYMBOL_PREFIX))"
 
 # Create temporary dir for module support files
 # clean it up only when building all modules
index f8fa411..c205035 100644 (file)
 
 static efi_system_table_t *sys_table;
 
+static void efi_char16_printk(efi_char16_t *str)
+{
+       struct efi_simple_text_output_protocol *out;
+
+       out = (struct efi_simple_text_output_protocol *)sys_table->con_out;
+       efi_call_phys2(out->output_string, out, str);
+}
+
 static void efi_printk(char *str)
 {
        char *s8;
 
        for (s8 = str; *s8; s8++) {
-               struct efi_simple_text_output_protocol *out;
                efi_char16_t ch[2] = { 0 };
 
                ch[0] = *s8;
-               out = (struct efi_simple_text_output_protocol *)sys_table->con_out;
-
                if (*s8 == '\n') {
                        efi_char16_t nl[2] = { '\r', 0 };
-                       efi_call_phys2(out->output_string, out, nl);
+                       efi_char16_printk(nl);
                }
 
-               efi_call_phys2(out->output_string, out, ch);
+               efi_char16_printk(ch);
        }
 }
 
@@ -709,7 +714,12 @@ static efi_status_t handle_ramdisks(efi_loaded_image_t *image,
                        if ((u8 *)p >= (u8 *)filename_16 + sizeof(filename_16))
                                break;
 
-                       *p++ = *str++;
+                       if (*str == '/') {
+                               *p++ = '\\';
+                               *str++;
+                       } else {
+                               *p++ = *str++;
+                       }
                }
 
                *p = '\0';
@@ -737,7 +747,9 @@ static efi_status_t handle_ramdisks(efi_loaded_image_t *image,
                status = efi_call_phys5(fh->open, fh, &h, filename_16,
                                        EFI_FILE_MODE_READ, (u64)0);
                if (status != EFI_SUCCESS) {
-                       efi_printk("Failed to open initrd file\n");
+                       efi_printk("Failed to open initrd file: ");
+                       efi_char16_printk(filename_16);
+                       efi_printk("\n");
                        goto close_handles;
                }
 
index 28677c5..60c89f3 100644 (file)
@@ -102,7 +102,14 @@ extern void efi_call_phys_epilog(void);
 extern void efi_unmap_memmap(void);
 extern void efi_memory_uc(u64 addr, unsigned long size);
 
-#ifndef CONFIG_EFI
+#ifdef CONFIG_EFI
+
+static inline bool efi_is_native(void)
+{
+       return IS_ENABLED(CONFIG_X86_64) == efi_enabled(EFI_64BIT);
+}
+
+#else
 /*
  * IF EFI is not configured, have the EFI calls return -ENOSYS.
  */
index 48d9d4e..992f442 100644 (file)
@@ -5,8 +5,6 @@
 #include <asm/setup.h>
 #include <asm/bios_ebda.h>
 
-#define BIOS_LOWMEM_KILOBYTES 0x413
-
 /*
  * The BIOS places the EBDA/XBDA at the top of conventional
  * memory, and usually decreases the reported amount of
  * chipset: reserve a page before VGA to prevent PCI prefetch
  * into it (errata #56). Usually the page is reserved anyways,
  * unless you have no PS/2 mouse plugged in.
+ *
+ * This functions is deliberately very conservative.  Losing
+ * memory in the bottom megabyte is rarely a problem, as long
+ * as we have enough memory to install the trampoline.  Using
+ * memory that is in use by the BIOS or by some DMA device
+ * the BIOS didn't shut down *is* a big problem.
  */
+
+#define BIOS_LOWMEM_KILOBYTES  0x413
+#define LOWMEM_CAP             0x9f000U        /* Absolute maximum */
+#define INSANE_CUTOFF          0x20000U        /* Less than this = insane */
+
 void __init reserve_ebda_region(void)
 {
        unsigned int lowmem, ebda_addr;
 
-       /* To determine the position of the EBDA and the */
-       /* end of conventional memory, we need to look at */
-       /* the BIOS data area. In a paravirtual environment */
-       /* that area is absent. We'll just have to assume */
-       /* that the paravirt case can handle memory setup */
-       /* correctly, without our help. */
+       /*
+        * To determine the position of the EBDA and the
+        * end of conventional memory, we need to look at
+        * the BIOS data area. In a paravirtual environment
+        * that area is absent. We'll just have to assume
+        * that the paravirt case can handle memory setup
+        * correctly, without our help.
+        */
        if (paravirt_enabled())
                return;
 
@@ -37,19 +48,23 @@ void __init reserve_ebda_region(void)
        /* start of EBDA area */
        ebda_addr = get_bios_ebda();
 
-       /* Fixup: bios puts an EBDA in the top 64K segment */
-       /* of conventional memory, but does not adjust lowmem. */
-       if ((lowmem - ebda_addr) <= 0x10000)
-               lowmem = ebda_addr;
+       /*
+        * Note: some old Dells seem to need 4k EBDA without
+        * reporting so, so just consider the memory above 0x9f000
+        * to be off limits (bugzilla 2990).
+        */
+
+       /* If the EBDA address is below 128K, assume it is bogus */
+       if (ebda_addr < INSANE_CUTOFF)
+               ebda_addr = LOWMEM_CAP;
 
-       /* Fixup: bios does not report an EBDA at all. */
-       /* Some old Dells seem to need 4k anyhow (bugzilla 2990) */
-       if ((ebda_addr == 0) && (lowmem >= 0x9f000))
-               lowmem = 0x9f000;
+       /* If lowmem is less than 128K, assume it is bogus */
+       if (lowmem < INSANE_CUTOFF)
+               lowmem = LOWMEM_CAP;
 
-       /* Paranoia: should never happen, but... */
-       if ((lowmem == 0) || (lowmem >= 0x100000))
-               lowmem = 0x9f000;
+       /* Use the lower of the lowmem and EBDA markers as the cutoff */
+       lowmem = min(lowmem, ebda_addr);
+       lowmem = min(lowmem, LOWMEM_CAP); /* Absolute cap */
 
        /* reserve all memory between lowmem and the 1MB mark */
        memblock_reserve(lowmem, 0x100000 - lowmem);
index b7de3b2..6859e96 100644 (file)
@@ -48,7 +48,7 @@ L3_START_KERNEL = pud_index(__START_KERNEL_map)
        .globl startup_64
 startup_64:
        /*
-        * At this point the CPU runs in 64bit mode CS.L = 1 CS.D = 1,
+        * At this point the CPU runs in 64bit mode CS.L = 1 CS.D = 0,
         * and someone has loaded an identity mapped page table
         * for us.  These identity mapped page tables map all of the
         * kernel pages and possibly all of memory.
@@ -159,7 +159,7 @@ startup_64:
        jmp 1f
 ENTRY(secondary_startup_64)
        /*
-        * At this point the CPU runs in 64bit mode CS.L = 1 CS.D = 1,
+        * At this point the CPU runs in 64bit mode CS.L = 1 CS.D = 0,
         * and someone has loaded a mapped page table.
         *
         * %rsi holds a physical pointer to real_mode_data.
index 9c857f0..e89acdf 100644 (file)
@@ -1196,8 +1196,7 @@ void __init setup_arch(char **cmdline_p)
         * mismatched firmware/kernel archtectures since there is no
         * support for runtime services.
         */
-       if (efi_enabled(EFI_BOOT) &&
-           IS_ENABLED(CONFIG_X86_64) != efi_enabled(EFI_64BIT)) {
+       if (efi_enabled(EFI_BOOT) && !efi_is_native()) {
                pr_info("efi: Setup done, disabling due to 32/64-bit mismatch\n");
                efi_unmap_memmap();
        }
index 2f81db4..5f2ecaf 100644 (file)
@@ -69,11 +69,6 @@ struct efi_memory_map memmap;
 static struct efi efi_phys __initdata;
 static efi_system_table_t efi_systab __initdata;
 
-static inline bool efi_is_native(void)
-{
-       return IS_ENABLED(CONFIG_X86_64) == efi_enabled(EFI_64BIT);
-}
-
 unsigned long x86_efi_facility;
 
 /*
@@ -85,7 +80,7 @@ int efi_enabled(int facility)
 }
 EXPORT_SYMBOL(efi_enabled);
 
-static bool disable_runtime = false;
+static bool __initdata disable_runtime = false;
 static int __init setup_noefi(char *arg)
 {
        disable_runtime = true;
index 3200060..92ed969 100644 (file)
@@ -266,7 +266,8 @@ config ACPI_CUSTOM_DSDT
        default ACPI_CUSTOM_DSDT_FILE != ""
 
 config ACPI_INITRD_TABLE_OVERRIDE
-       bool "ACPI tables can be passed via uncompressed cpio in initrd"
+       bool "ACPI tables override via initrd"
+       depends on BLK_DEV_INITRD && X86
        default n
        help
          This option provides functionality to override arbitrary ACPI tables
index fed08b6..7320bf8 100644 (file)
@@ -79,6 +79,7 @@
 #include <linux/device.h>
 #include <linux/slab.h>
 #include <linux/pstore.h>
+#include <linux/ctype.h>
 
 #include <linux/fs.h>
 #include <linux/ramfs.h>
@@ -908,6 +909,48 @@ static struct inode *efivarfs_get_inode(struct super_block *sb,
        return inode;
 }
 
+/*
+ * Return true if 'str' is a valid efivarfs filename of the form,
+ *
+ *     VariableName-12345678-1234-1234-1234-1234567891bc
+ */
+static bool efivarfs_valid_name(const char *str, int len)
+{
+       static const char dashes[GUID_LEN] = {
+               [8] = 1, [13] = 1, [18] = 1, [23] = 1
+       };
+       const char *s = str + len - GUID_LEN;
+       int i;
+
+       /*
+        * We need a GUID, plus at least one letter for the variable name,
+        * plus the '-' separator
+        */
+       if (len < GUID_LEN + 2)
+               return false;
+
+       /* GUID should be right after the first '-' */
+       if (s - 1 != strchr(str, '-'))
+               return false;
+
+       /*
+        * Validate that 's' is of the correct format, e.g.
+        *
+        *      12345678-1234-1234-1234-123456789abc
+        */
+       for (i = 0; i < GUID_LEN; i++) {
+               if (dashes[i]) {
+                       if (*s++ != '-')
+                               return false;
+               } else {
+                       if (!isxdigit(*s++))
+                               return false;
+               }
+       }
+
+       return true;
+}
+
 static void efivarfs_hex_to_guid(const char *str, efi_guid_t *guid)
 {
        guid->b[0] = hex_to_bin(str[6]) << 4 | hex_to_bin(str[7]);
@@ -936,11 +979,7 @@ static int efivarfs_create(struct inode *dir, struct dentry *dentry,
        struct efivar_entry *var;
        int namelen, i = 0, err = 0;
 
-       /*
-        * We need a GUID, plus at least one letter for the variable name,
-        * plus the '-' separator
-        */
-       if (dentry->d_name.len < GUID_LEN + 2)
+       if (!efivarfs_valid_name(dentry->d_name.name, dentry->d_name.len))
                return -EINVAL;
 
        inode = efivarfs_get_inode(dir->i_sb, dir, mode, 0);
@@ -1012,6 +1051,84 @@ static int efivarfs_unlink(struct inode *dir, struct dentry *dentry)
        return -EINVAL;
 };
 
+/*
+ * Compare two efivarfs file names.
+ *
+ * An efivarfs filename is composed of two parts,
+ *
+ *     1. A case-sensitive variable name
+ *     2. A case-insensitive GUID
+ *
+ * So we need to perform a case-sensitive match on part 1 and a
+ * case-insensitive match on part 2.
+ */
+static int efivarfs_d_compare(const struct dentry *parent, const struct inode *pinode,
+                             const struct dentry *dentry, const struct inode *inode,
+                             unsigned int len, const char *str,
+                             const struct qstr *name)
+{
+       int guid = len - GUID_LEN;
+
+       if (name->len != len)
+               return 1;
+
+       /* Case-sensitive compare for the variable name */
+       if (memcmp(str, name->name, guid))
+               return 1;
+
+       /* Case-insensitive compare for the GUID */
+       return strncasecmp(name->name + guid, str + guid, GUID_LEN);
+}
+
+static int efivarfs_d_hash(const struct dentry *dentry,
+                          const struct inode *inode, struct qstr *qstr)
+{
+       unsigned long hash = init_name_hash();
+       const unsigned char *s = qstr->name;
+       unsigned int len = qstr->len;
+
+       if (!efivarfs_valid_name(s, len))
+               return -EINVAL;
+
+       while (len-- > GUID_LEN)
+               hash = partial_name_hash(*s++, hash);
+
+       /* GUID is case-insensitive. */
+       while (len--)
+               hash = partial_name_hash(tolower(*s++), hash);
+
+       qstr->hash = end_name_hash(hash);
+       return 0;
+}
+
+/*
+ * Retaining negative dentries for an in-memory filesystem just wastes
+ * memory and lookup time: arrange for them to be deleted immediately.
+ */
+static int efivarfs_delete_dentry(const struct dentry *dentry)
+{
+       return 1;
+}
+
+static struct dentry_operations efivarfs_d_ops = {
+       .d_compare = efivarfs_d_compare,
+       .d_hash = efivarfs_d_hash,
+       .d_delete = efivarfs_delete_dentry,
+};
+
+static struct dentry *efivarfs_alloc_dentry(struct dentry *parent, char *name)
+{
+       struct qstr q;
+
+       q.name = name;
+       q.len = strlen(name);
+
+       if (efivarfs_d_hash(NULL, NULL, &q))
+               return NULL;
+
+       return d_alloc(parent, &q);
+}
+
 static int efivarfs_fill_super(struct super_block *sb, void *data, int silent)
 {
        struct inode *inode = NULL;
@@ -1027,6 +1144,7 @@ static int efivarfs_fill_super(struct super_block *sb, void *data, int silent)
        sb->s_blocksize_bits    = PAGE_CACHE_SHIFT;
        sb->s_magic             = EFIVARFS_MAGIC;
        sb->s_op                = &efivarfs_ops;
+       sb->s_d_op              = &efivarfs_d_ops;
        sb->s_time_gran         = 1;
 
        inode = efivarfs_get_inode(sb, NULL, S_IFDIR | 0755, 0);
@@ -1067,7 +1185,7 @@ static int efivarfs_fill_super(struct super_block *sb, void *data, int silent)
                if (!inode)
                        goto fail_name;
 
-               dentry = d_alloc_name(root, name);
+               dentry = efivarfs_alloc_dentry(root, name);
                if (!dentry)
                        goto fail_inode;
 
@@ -1084,7 +1202,7 @@ static int efivarfs_fill_super(struct super_block *sb, void *data, int silent)
 
                mutex_lock(&inode->i_mutex);
                inode->i_private = entry;
-               i_size_write(inode, size+4);
+               i_size_write(inode, size + sizeof(entry->var.Attributes));
                mutex_unlock(&inode->i_mutex);
                d_add(dentry, inode);
        }
@@ -1117,8 +1235,20 @@ static struct file_system_type efivarfs_type = {
        .kill_sb = efivarfs_kill_sb,
 };
 
+/*
+ * Handle negative dentry.
+ */
+static struct dentry *efivarfs_lookup(struct inode *dir, struct dentry *dentry,
+                                     unsigned int flags)
+{
+       if (dentry->d_name.len > NAME_MAX)
+               return ERR_PTR(-ENAMETOOLONG);
+       d_add(dentry, NULL);
+       return NULL;
+}
+
 static const struct inode_operations efivarfs_dir_inode_operations = {
-       .lookup = simple_lookup,
+       .lookup = efivarfs_lookup,
        .unlink = efivarfs_unlink,
        .create = efivarfs_create,
 };
index cf83e77..f190dfe 100644 (file)
 #define es_debug(fmt, ...)     no_printk(fmt, ##__VA_ARGS__)
 #endif
 
-#define EXTENT_STATUS_WRITTEN  0x80000000      /* written extent */
-#define EXTENT_STATUS_UNWRITTEN        0x40000000      /* unwritten extent */
-#define EXTENT_STATUS_DELAYED  0x20000000      /* delayed extent */
-#define EXTENT_STATUS_HOLE     0x10000000      /* hole */
+/*
+ * These flags live in the high bits of extent_status.es_pblk
+ */
+#define EXTENT_STATUS_WRITTEN  (1ULL << 63)
+#define EXTENT_STATUS_UNWRITTEN (1ULL << 62)
+#define EXTENT_STATUS_DELAYED  (1ULL << 61)
+#define EXTENT_STATUS_HOLE     (1ULL << 60)
 
 #define EXTENT_STATUS_FLAGS    (EXTENT_STATUS_WRITTEN | \
                                 EXTENT_STATUS_UNWRITTEN | \
@@ -58,22 +61,22 @@ extern int ext4_es_lookup_extent(struct inode *inode, ext4_lblk_t lblk,
 
 static inline int ext4_es_is_written(struct extent_status *es)
 {
-       return (es->es_pblk & EXTENT_STATUS_WRITTEN);
+       return (es->es_pblk & EXTENT_STATUS_WRITTEN) != 0;
 }
 
 static inline int ext4_es_is_unwritten(struct extent_status *es)
 {
-       return (es->es_pblk & EXTENT_STATUS_UNWRITTEN);
+       return (es->es_pblk & EXTENT_STATUS_UNWRITTEN) != 0;
 }
 
 static inline int ext4_es_is_delayed(struct extent_status *es)
 {
-       return (es->es_pblk & EXTENT_STATUS_DELAYED);
+       return (es->es_pblk & EXTENT_STATUS_DELAYED) != 0;
 }
 
 static inline int ext4_es_is_hole(struct extent_status *es)
 {
-       return (es->es_pblk & EXTENT_STATUS_HOLE);
+       return (es->es_pblk & EXTENT_STATUS_HOLE) != 0;
 }
 
 static inline ext4_fsblk_t ext4_es_status(struct extent_status *es)
index fed3def..779cf7c 100644 (file)
@@ -33,8 +33,7 @@ struct ieee1394_device_id {
        __u32 model_id;
        __u32 specifier_id;
        __u32 version;
-       kernel_ulong_t driver_data
-               __attribute__((aligned(sizeof(kernel_ulong_t))));
+       kernel_ulong_t driver_data;
 };
 
 
@@ -148,8 +147,7 @@ struct hid_device_id {
        __u16 group;
        __u32 vendor;
        __u32 product;
-       kernel_ulong_t driver_data
-               __attribute__((aligned(sizeof(kernel_ulong_t))));
+       kernel_ulong_t driver_data;
 };
 
 /* s390 CCW devices */
@@ -173,8 +171,6 @@ struct ccw_device_id {
 struct ap_device_id {
        __u16 match_flags;      /* which fields to match against */
        __u8 dev_type;          /* device type */
-       __u8 pad1;
-       __u32 pad2;
        kernel_ulong_t driver_info;
 };
 
@@ -184,13 +180,10 @@ struct ap_device_id {
 struct css_device_id {
        __u8 match_flags;
        __u8 type; /* subchannel type */
-       __u16 pad2;
-       __u32 pad3;
        kernel_ulong_t driver_data;
 };
 
-#define ACPI_ID_LEN    16 /* only 9 bytes needed here, 16 bytes are used */
-                          /* to workaround crosscompile issues */
+#define ACPI_ID_LEN    9
 
 struct acpi_device_id {
        __u8 id[ACPI_ID_LEN];
@@ -231,11 +224,7 @@ struct of_device_id
        char    name[32];
        char    type[32];
        char    compatible[128];
-#ifdef __KERNEL__
        const void *data;
-#else
-       kernel_ulong_t data;
-#endif
 };
 
 /* VIO */
@@ -260,24 +249,14 @@ struct pcmcia_device_id {
        /* for pseudo multi-function devices */
        __u8            device_no;
 
-       __u32           prod_id_hash[4]
-               __attribute__((aligned(sizeof(__u32))));
+       __u32           prod_id_hash[4];
 
        /* not matched against in kernelspace*/
-#ifdef __KERNEL__
        const char *    prod_id[4];
-#else
-       kernel_ulong_t  prod_id[4]
-               __attribute__((aligned(sizeof(kernel_ulong_t))));
-#endif
 
        /* not matched against */
        kernel_ulong_t  driver_info;
-#ifdef __KERNEL__
        char *          cisfile;
-#else
-       kernel_ulong_t  cisfile;
-#endif
 };
 
 #define PCMCIA_DEV_ID_MATCH_MANF_ID    0x0001
@@ -373,8 +352,7 @@ struct sdio_device_id {
        __u8    class;                  /* Standard interface or SDIO_ANY_ID */
        __u16   vendor;                 /* Vendor or SDIO_ANY_ID */
        __u16   device;                 /* Device ID or SDIO_ANY_ID */
-       kernel_ulong_t driver_data      /* Data private to the driver */
-               __attribute__((aligned(sizeof(kernel_ulong_t))));
+       kernel_ulong_t driver_data;     /* Data private to the driver */
 };
 
 /* SSB core, see drivers/ssb/ */
@@ -420,8 +398,7 @@ struct virtio_device_id {
  */
 struct hv_vmbus_device_id {
        __u8 guid[16];
-       kernel_ulong_t driver_data      /* Data private to the driver */
-                       __attribute__((aligned(sizeof(kernel_ulong_t))));
+       kernel_ulong_t driver_data;     /* Data private to the driver */
 };
 
 /* rpmsg */
@@ -440,8 +417,7 @@ struct rpmsg_device_id {
 
 struct i2c_device_id {
        char name[I2C_NAME_SIZE];
-       kernel_ulong_t driver_data      /* Data private to the driver */
-                       __attribute__((aligned(sizeof(kernel_ulong_t))));
+       kernel_ulong_t driver_data;     /* Data private to the driver */
 };
 
 /* spi */
@@ -451,8 +427,7 @@ struct i2c_device_id {
 
 struct spi_device_id {
        char name[SPI_NAME_SIZE];
-       kernel_ulong_t driver_data      /* Data private to the driver */
-                       __attribute__((aligned(sizeof(kernel_ulong_t))));
+       kernel_ulong_t driver_data;     /* Data private to the driver */
 };
 
 /* dmi */
@@ -484,15 +459,6 @@ struct dmi_strmatch {
        char substr[79];
 };
 
-#ifndef __KERNEL__
-struct dmi_system_id {
-       kernel_ulong_t callback;
-       kernel_ulong_t ident;
-       struct dmi_strmatch matches[4];
-       kernel_ulong_t driver_data
-                       __attribute__((aligned(sizeof(kernel_ulong_t))));
-};
-#else
 struct dmi_system_id {
        int (*callback)(const struct dmi_system_id *);
        const char *ident;
@@ -506,7 +472,6 @@ struct dmi_system_id {
  *     error: storage size of '__mod_dmi_device_table' isn't known
  */
 #define dmi_device_id dmi_system_id
-#endif
 
 #define DMI_MATCH(a, b)        { a, b }
 
@@ -515,8 +480,7 @@ struct dmi_system_id {
 
 struct platform_device_id {
        char name[PLATFORM_NAME_SIZE];
-       kernel_ulong_t driver_data
-                       __attribute__((aligned(sizeof(kernel_ulong_t))));
+       kernel_ulong_t driver_data;
 };
 
 #define MDIO_MODULE_PREFIX     "mdio:"
@@ -572,11 +536,7 @@ struct isapnp_device_id {
 struct amba_id {
        unsigned int            id;
        unsigned int            mask;
-#ifndef __KERNEL__
-       kernel_ulong_t          data;
-#else
        void                    *data;
-#endif
 };
 
 /*
index 953a20e..bbde5f1 100644 (file)
@@ -125,11 +125,19 @@ $(obj)/config_data.h: $(obj)/config_data.gz FORCE
 
 $(obj)/time.o: $(obj)/timeconst.h
 
-quiet_cmd_timeconst  = TIMEC   $@
-      cmd_timeconst  = $(PERL) $< $(CONFIG_HZ) > $@
+quiet_cmd_hzfile = HZFILE  $@
+      cmd_hzfile = echo "hz=$(CONFIG_HZ)" > $@
+
+targets += hz.bc
+$(obj)/hz.bc: $(objtree)/include/config/hz.h FORCE
+       $(call if_changed,hzfile)
+
+quiet_cmd_bc  = BC      $@
+      cmd_bc  = bc -q $(filter-out FORCE,$^) > $@
+
 targets += timeconst.h
-$(obj)/timeconst.h: $(src)/timeconst.pl FORCE
-       $(call if_changed,timeconst)
+$(obj)/timeconst.h: $(obj)/hz.bc $(src)/timeconst.bc FORCE
+       $(call if_changed,bc)
 
 ifeq ($(CONFIG_MODULE_SIG),y)
 #
diff --git a/kernel/timeconst.bc b/kernel/timeconst.bc
new file mode 100644 (file)
index 0000000..511bdf2
--- /dev/null
@@ -0,0 +1,108 @@
+scale=0
+
+define gcd(a,b) {
+       auto t;
+       while (b) {
+               t = b;
+               b = a % b;
+               a = t;
+       }
+       return a;
+}
+
+/* Division by reciprocal multiplication. */
+define fmul(b,n,d) {
+       return (2^b*n+d-1)/d;
+}
+
+/* Adjustment factor when a ceiling value is used.  Use as:
+   (imul * n) + (fmulxx * n + fadjxx) >> xx) */
+define fadj(b,n,d) {
+       auto v;
+       d = d/gcd(n,d);
+       v = 2^b*(d-1)/d;
+       return v;
+}
+
+/* Compute the appropriate mul/adj values as well as a shift count,
+   which brings the mul value into the range 2^b-1 <= x < 2^b.  Such
+   a shift value will be correct in the signed integer range and off
+   by at most one in the upper half of the unsigned range. */
+define fmuls(b,n,d) {
+       auto s, m;
+       for (s = 0; 1; s++) {
+               m = fmul(s,n,d);
+               if (m >= 2^(b-1))
+                       return s;
+       }
+       return 0;
+}
+
+define timeconst(hz) {
+       print "/* Automatically generated by kernel/timeconst.bc */\n"
+       print "/* Time conversion constants for HZ == ", hz, " */\n"
+       print "\n"
+
+       print "#ifndef KERNEL_TIMECONST_H\n"
+       print "#define KERNEL_TIMECONST_H\n\n"
+
+       print "#include <linux/param.h>\n"
+       print "#include <linux/types.h>\n\n"
+
+       print "#if HZ != ", hz, "\n"
+       print "#error \qkernel/timeconst.h has the wrong HZ value!\q\n"
+       print "#endif\n\n"
+
+       if (hz < 2) {
+               print "#error Totally bogus HZ value!\n"
+       } else {
+               s=fmuls(32,1000,hz)
+               obase=16
+               print "#define HZ_TO_MSEC_MUL32\tU64_C(0x", fmul(s,1000,hz), ")\n"
+               print "#define HZ_TO_MSEC_ADJ32\tU64_C(0x", fadj(s,1000,hz), ")\n"
+               obase=10
+               print "#define HZ_TO_MSEC_SHR32\t", s, "\n"
+
+               s=fmuls(32,hz,1000)
+               obase=16
+               print "#define MSEC_TO_HZ_MUL32\tU64_C(0x", fmul(s,hz,1000), ")\n"
+               print "#define MSEC_TO_HZ_ADJ32\tU64_C(0x", fadj(s,hz,1000), ")\n"
+               obase=10
+               print "#define MSEC_TO_HZ_SHR32\t", s, "\n"
+
+               obase=10
+               cd=gcd(hz,1000)
+               print "#define HZ_TO_MSEC_NUM\t\t", 1000/cd, "\n"
+               print "#define HZ_TO_MSEC_DEN\t\t", hz/cd, "\n"
+               print "#define MSEC_TO_HZ_NUM\t\t", hz/cd, "\n"
+               print "#define MSEC_TO_HZ_DEN\t\t", 1000/cd, "\n"
+               print "\n"
+
+               s=fmuls(32,1000000,hz)
+               obase=16
+               print "#define HZ_TO_USEC_MUL32\tU64_C(0x", fmul(s,1000000,hz), ")\n"
+               print "#define HZ_TO_USEC_ADJ32\tU64_C(0x", fadj(s,1000000,hz), ")\n"
+               obase=10
+               print "#define HZ_TO_USEC_SHR32\t", s, "\n"
+
+               s=fmuls(32,hz,1000000)
+               obase=16
+               print "#define USEC_TO_HZ_MUL32\tU64_C(0x", fmul(s,hz,1000000), ")\n"
+               print "#define USEC_TO_HZ_ADJ32\tU64_C(0x", fadj(s,hz,1000000), ")\n"
+               obase=10
+               print "#define USEC_TO_HZ_SHR32\t", s, "\n"
+
+               obase=10
+               cd=gcd(hz,1000000)
+               print "#define HZ_TO_USEC_NUM\t\t", 1000000/cd, "\n"
+               print "#define HZ_TO_USEC_DEN\t\t", hz/cd, "\n"
+               print "#define USEC_TO_HZ_NUM\t\t", hz/cd, "\n"
+               print "#define USEC_TO_HZ_DEN\t\t", 1000000/cd, "\n"
+               print "\n"
+
+               print "#endif /* KERNEL_TIMECONST_H */\n"
+       }
+       halt
+}
+
+timeconst(hz)
diff --git a/kernel/timeconst.pl b/kernel/timeconst.pl
deleted file mode 100644 (file)
index 3f42652..0000000
+++ /dev/null
@@ -1,376 +0,0 @@
-#!/usr/bin/perl
-# -----------------------------------------------------------------------
-#
-#   Copyright 2007-2008 rPath, Inc. - All Rights Reserved
-#
-#   This file is part of the Linux kernel, and is made available under
-#   the terms of the GNU General Public License version 2 or (at your
-#   option) any later version; incorporated herein by reference.
-#
-# -----------------------------------------------------------------------
-#
-
-#
-# Usage: timeconst.pl HZ > timeconst.h
-#
-
-# Precomputed values for systems without Math::BigInt
-# Generated by:
-# timeconst.pl --can 24 32 48 64 100 122 128 200 250 256 300 512 1000 1024 1200
-%canned_values = (
-       24 => [
-               '0xa6aaaaab','0x2aaaaaa',26,
-               125,3,
-               '0xc49ba5e4','0x1fbe76c8b4',37,
-               3,125,
-               '0xa2c2aaab','0xaaaa',16,
-               125000,3,
-               '0xc9539b89','0x7fffbce4217d',47,
-               3,125000,
-       ], 32 => [
-               '0xfa000000','0x6000000',27,
-               125,4,
-               '0x83126e98','0xfdf3b645a',36,
-               4,125,
-               '0xf4240000','0x0',17,
-               31250,1,
-               '0x8637bd06','0x3fff79c842fa',46,
-               1,31250,
-       ], 48 => [
-               '0xa6aaaaab','0x6aaaaaa',27,
-               125,6,
-               '0xc49ba5e4','0xfdf3b645a',36,
-               6,125,
-               '0xa2c2aaab','0x15555',17,
-               62500,3,
-               '0xc9539b89','0x3fffbce4217d',46,
-               3,62500,
-       ], 64 => [
-               '0xfa000000','0xe000000',28,
-               125,8,
-               '0x83126e98','0x7ef9db22d',35,
-               8,125,
-               '0xf4240000','0x0',18,
-               15625,1,
-               '0x8637bd06','0x1fff79c842fa',45,
-               1,15625,
-       ], 100 => [
-               '0xa0000000','0x0',28,
-               10,1,
-               '0xcccccccd','0x733333333',35,
-               1,10,
-               '0x9c400000','0x0',18,
-               10000,1,
-               '0xd1b71759','0x1fff2e48e8a7',45,
-               1,10000,
-       ], 122 => [
-               '0x8325c53f','0xfbcda3a',28,
-               500,61,
-               '0xf9db22d1','0x7fbe76c8b',35,
-               61,500,
-               '0x8012e2a0','0x3ef36',18,
-               500000,61,
-               '0xffda4053','0x1ffffbce4217',45,
-               61,500000,
-       ], 128 => [
-               '0xfa000000','0x1e000000',29,
-               125,16,
-               '0x83126e98','0x3f7ced916',34,
-               16,125,
-               '0xf4240000','0x40000',19,
-               15625,2,
-               '0x8637bd06','0xfffbce4217d',44,
-               2,15625,
-       ], 200 => [
-               '0xa0000000','0x0',29,
-               5,1,
-               '0xcccccccd','0x333333333',34,
-               1,5,
-               '0x9c400000','0x0',19,
-               5000,1,
-               '0xd1b71759','0xfff2e48e8a7',44,
-               1,5000,
-       ], 250 => [
-               '0x80000000','0x0',29,
-               4,1,
-               '0x80000000','0x180000000',33,
-               1,4,
-               '0xfa000000','0x0',20,
-               4000,1,
-               '0x83126e98','0x7ff7ced9168',43,
-               1,4000,
-       ], 256 => [
-               '0xfa000000','0x3e000000',30,
-               125,32,
-               '0x83126e98','0x1fbe76c8b',33,
-               32,125,
-               '0xf4240000','0xc0000',20,
-               15625,4,
-               '0x8637bd06','0x7ffde7210be',43,
-               4,15625,
-       ], 300 => [
-               '0xd5555556','0x2aaaaaaa',30,
-               10,3,
-               '0x9999999a','0x1cccccccc',33,
-               3,10,
-               '0xd0555556','0xaaaaa',20,
-               10000,3,
-               '0x9d495183','0x7ffcb923a29',43,
-               3,10000,
-       ], 512 => [
-               '0xfa000000','0x7e000000',31,
-               125,64,
-               '0x83126e98','0xfdf3b645',32,
-               64,125,
-               '0xf4240000','0x1c0000',21,
-               15625,8,
-               '0x8637bd06','0x3ffef39085f',42,
-               8,15625,
-       ], 1000 => [
-               '0x80000000','0x0',31,
-               1,1,
-               '0x80000000','0x0',31,
-               1,1,
-               '0xfa000000','0x0',22,
-               1000,1,
-               '0x83126e98','0x1ff7ced9168',41,
-               1,1000,
-       ], 1024 => [
-               '0xfa000000','0xfe000000',32,
-               125,128,
-               '0x83126e98','0x7ef9db22',31,
-               128,125,
-               '0xf4240000','0x3c0000',22,
-               15625,16,
-               '0x8637bd06','0x1fff79c842f',41,
-               16,15625,
-       ], 1200 => [
-               '0xd5555556','0xd5555555',32,
-               5,6,
-               '0x9999999a','0x66666666',31,
-               6,5,
-               '0xd0555556','0x2aaaaa',22,
-               2500,3,
-               '0x9d495183','0x1ffcb923a29',41,
-               3,2500,
-       ]
-);
-
-$has_bigint = eval 'use Math::BigInt qw(bgcd); 1;';
-
-sub bint($)
-{
-       my($x) = @_;
-       return Math::BigInt->new($x);
-}
-
-#
-# Constants for division by reciprocal multiplication.
-# (bits, numerator, denominator)
-#
-sub fmul($$$)
-{
-       my ($b,$n,$d) = @_;
-
-       $n = bint($n);
-       $d = bint($d);
-
-       return scalar (($n << $b)+$d-bint(1))/$d;
-}
-
-sub fadj($$$)
-{
-       my($b,$n,$d) = @_;
-
-       $n = bint($n);
-       $d = bint($d);
-
-       $d = $d/bgcd($n, $d);
-       return scalar (($d-bint(1)) << $b)/$d;
-}
-
-sub fmuls($$$) {
-       my($b,$n,$d) = @_;
-       my($s,$m);
-       my($thres) = bint(1) << ($b-1);
-
-       $n = bint($n);
-       $d = bint($d);
-
-       for ($s = 0; 1; $s++) {
-               $m = fmul($s,$n,$d);
-               return $s if ($m >= $thres);
-       }
-       return 0;
-}
-
-# Generate a hex value if the result fits in 64 bits;
-# otherwise skip.
-sub bignum_hex($) {
-       my($x) = @_;
-       my $s = $x->as_hex();
-
-       return (length($s) > 18) ? undef : $s;
-}
-
-# Provides mul, adj, and shr factors for a specific
-# (bit, time, hz) combination
-sub muladj($$$) {
-       my($b, $t, $hz) = @_;
-       my $s = fmuls($b, $t, $hz);
-       my $m = fmul($s, $t, $hz);
-       my $a = fadj($s, $t, $hz);
-       return (bignum_hex($m), bignum_hex($a), $s);
-}
-
-# Provides numerator, denominator values
-sub numden($$) {
-       my($n, $d) = @_;
-       my $g = bgcd($n, $d);
-       return ($n/$g, $d/$g);
-}
-
-# All values for a specific (time, hz) combo
-sub conversions($$) {
-       my ($t, $hz) = @_;
-       my @val = ();
-
-       # HZ_TO_xx
-       push(@val, muladj(32, $t, $hz));
-       push(@val, numden($t, $hz));
-
-       # xx_TO_HZ
-       push(@val, muladj(32, $hz, $t));
-       push(@val, numden($hz, $t));
-
-       return @val;
-}
-
-sub compute_values($) {
-       my($hz) = @_;
-       my @val = ();
-       my $s, $m, $a, $g;
-
-       if (!$has_bigint) {
-               die "$0: HZ == $hz not canned and ".
-                   "Math::BigInt not available\n";
-       }
-
-       # MSEC conversions
-       push(@val, conversions(1000, $hz));
-
-       # USEC conversions
-       push(@val, conversions(1000000, $hz));
-
-       return @val;
-}
-
-sub outputval($$)
-{
-       my($name, $val) = @_;
-       my $csuf;
-
-       if (defined($val)) {
-           if ($name !~ /SHR/) {
-               $val = "U64_C($val)";
-           }
-           printf "#define %-23s %s\n", $name.$csuf, $val.$csuf;
-       }
-}
-
-sub output($@)
-{
-       my($hz, @val) = @_;
-       my $pfx, $bit, $suf, $s, $m, $a;
-
-       print "/* Automatically generated by kernel/timeconst.pl */\n";
-       print "/* Conversion constants for HZ == $hz */\n";
-       print "\n";
-       print "#ifndef KERNEL_TIMECONST_H\n";
-       print "#define KERNEL_TIMECONST_H\n";
-       print "\n";
-
-       print "#include <linux/param.h>\n";
-       print "#include <linux/types.h>\n";
-
-       print "\n";
-       print "#if HZ != $hz\n";
-       print "#error \"kernel/timeconst.h has the wrong HZ value!\"\n";
-       print "#endif\n";
-       print "\n";
-
-       foreach $pfx ('HZ_TO_MSEC','MSEC_TO_HZ',
-                     'HZ_TO_USEC','USEC_TO_HZ') {
-               foreach $bit (32) {
-                       foreach $suf ('MUL', 'ADJ', 'SHR') {
-                               outputval("${pfx}_$suf$bit", shift(@val));
-                       }
-               }
-               foreach $suf ('NUM', 'DEN') {
-                       outputval("${pfx}_$suf", shift(@val));
-               }
-       }
-
-       print "\n";
-       print "#endif /* KERNEL_TIMECONST_H */\n";
-}
-
-# Pretty-print Perl values
-sub perlvals(@) {
-       my $v;
-       my @l = ();
-
-       foreach $v (@_) {
-               if (!defined($v)) {
-                       push(@l, 'undef');
-               } elsif ($v =~ /^0x/) {
-                       push(@l, "\'".$v."\'");
-               } else {
-                       push(@l, $v.'');
-               }
-       }
-       return join(',', @l);
-}
-
-($hz) = @ARGV;
-
-# Use this to generate the %canned_values structure
-if ($hz eq '--can') {
-       shift(@ARGV);
-       @hzlist = sort {$a <=> $b} (@ARGV);
-
-       print "# Precomputed values for systems without Math::BigInt\n";
-       print "# Generated by:\n";
-       print "# timeconst.pl --can ", join(' ', @hzlist), "\n";
-       print "\%canned_values = (\n";
-       my $pf = "\t";
-       foreach $hz (@hzlist) {
-               my @values = compute_values($hz);
-               print "$pf$hz => [\n";
-               while (scalar(@values)) {
-                       my $bit;
-                       foreach $bit (32) {
-                               my $m = shift(@values);
-                               my $a = shift(@values);
-                               my $s = shift(@values);
-                               print "\t\t", perlvals($m,$a,$s), ",\n";
-                       }
-                       my $n = shift(@values);
-                       my $d = shift(@values);
-                       print "\t\t", perlvals($n,$d), ",\n";
-               }
-               print "\t]";
-               $pf = ', ';
-       }
-       print "\n);\n";
-} else {
-       $hz += 0;                       # Force to number
-       if ($hz < 1) {
-               die "Usage: $0 HZ\n";
-       }
-
-       $cv = $canned_values{$hz};
-       @val = defined($cv) ? @$cv : compute_values($hz);
-       output($hz, @val);
-}
-exit 0;
index 06ba4a7..25f216a 100644 (file)
@@ -7,15 +7,15 @@
 #
 # ==========================================================================
 
-# called may set destination dir (when installing to asm/)
-_dst := $(or $(destination-y),$(dst),$(obj))
-
 # generated header directory
 gen := $(if $(gen),$(gen),$(subst include/,include/generated/,$(obj)))
 
 kbuild-file := $(srctree)/$(obj)/Kbuild
 include $(kbuild-file)
 
+# called may set destination dir (when installing to asm/)
+_dst := $(or $(destination-y),$(dst),$(obj))
+
 old-kbuild-file := $(srctree)/$(subst uapi/,,$(obj))/Kbuild
 ifneq ($(wildcard $(old-kbuild-file)),)
 include $(old-kbuild-file)
index a1cb022..cf82c83 100644 (file)
@@ -66,10 +66,6 @@ modules   := $(patsubst %.o,%.ko, $(wildcard $(__modules:.ko=.o)))
 # Stop after building .o files if NOFINAL is set. Makes compile tests quicker
 _modpost: $(if $(KBUILD_MODPOST_NOFINAL), $(modules:.ko:.o),$(modules))
 
-ifneq ($(KBUILD_BUILDHOST),$(ARCH))
-        cross_build := 1
-endif
-
 # Step 2), invoke modpost
 #  Includes step 3,4
 modpost = scripts/mod/modpost                    \
@@ -80,8 +76,7 @@ modpost = scripts/mod/modpost                    \
  $(if $(KBUILD_EXTRA_SYMBOLS), $(patsubst %, -e %,$(KBUILD_EXTRA_SYMBOLS))) \
  $(if $(KBUILD_EXTMOD),-o $(modulesymfile))      \
  $(if $(CONFIG_DEBUG_SECTION_MISMATCH),,-S)      \
- $(if $(KBUILD_EXTMOD)$(KBUILD_MODPOST_WARN),-w) \
- $(if $(cross_build),-c)
+ $(if $(KBUILD_EXTMOD)$(KBUILD_MODPOST_WARN),-w)
 
 quiet_cmd_modpost = MODPOST $(words $(filter-out vmlinux FORCE, $^)) modules
       cmd_modpost = $(modpost) -s
index 1a49d1c..85d3189 100755 (executable)
@@ -2,6 +2,15 @@
 
 SPATCH="`which ${SPATCH:=spatch}`"
 
+# The verbosity may be set by the environmental parameter V=
+# as for example with 'make V=1 coccicheck'
+
+if [ -n "$V" -a "$V" != "0" ]; then
+       VERBOSE=1
+else
+       VERBOSE=0
+fi
+
 if [ "$C" = "1" -o "$C" = "2" ]; then
     ONLINE=1
 
@@ -46,6 +55,14 @@ if [ "$ONLINE" = "0" ] ; then
     echo ''
 fi
 
+run_cmd() {
+       if [ $VERBOSE -ne 0 ] ; then
+               echo "Running: $@"
+       fi
+       eval $@
+}
+
+
 coccinelle () {
     COCCI="$1"
 
@@ -55,7 +72,7 @@ coccinelle () {
 #
 #    $SPATCH -D $MODE $FLAGS -parse_cocci $COCCI $OPT > /dev/null
 
-    if [ "$ONLINE" = "0" ] ; then
+    if [ $VERBOSE -ne 0 ] ; then
 
        FILE=`echo $COCCI | sed "s|$srctree/||"`
 
@@ -91,15 +108,21 @@ coccinelle () {
     fi
 
     if [ "$MODE" = "chain" ] ; then
-       $SPATCH -D patch   $FLAGS -sp_file $COCCI $OPT $OPTIONS               || \
-       $SPATCH -D report  $FLAGS -sp_file $COCCI $OPT $OPTIONS -no_show_diff || \
-       $SPATCH -D context $FLAGS -sp_file $COCCI $OPT $OPTIONS               || \
-       $SPATCH -D org     $FLAGS -sp_file $COCCI $OPT $OPTIONS -no_show_diff || exit 1
+       run_cmd $SPATCH -D patch   \
+               $FLAGS -sp_file $COCCI $OPT $OPTIONS               || \
+       run_cmd $SPATCH -D report  \
+               $FLAGS -sp_file $COCCI $OPT $OPTIONS -no_show_diff || \
+       run_cmd $SPATCH -D context \
+               $FLAGS -sp_file $COCCI $OPT $OPTIONS               || \
+       run_cmd $SPATCH -D org     \
+               $FLAGS -sp_file $COCCI $OPT $OPTIONS -no_show_diff || exit 1
     elif [ "$MODE" = "rep+ctxt" ] ; then
-       $SPATCH -D report  $FLAGS -sp_file $COCCI $OPT $OPTIONS -no_show_diff && \
-       $SPATCH -D context $FLAGS -sp_file $COCCI $OPT $OPTIONS || exit 1
+       run_cmd $SPATCH -D report  \
+               $FLAGS -sp_file $COCCI $OPT $OPTIONS -no_show_diff && \
+       run_cmd $SPATCH -D context \
+               $FLAGS -sp_file $COCCI $OPT $OPTIONS || exit 1
     else
-       $SPATCH -D $MODE   $FLAGS -sp_file $COCCI $OPT $OPTIONS || exit 1
+       run_cmd $SPATCH -D $MODE   $FLAGS -sp_file $COCCI $OPT $OPTIONS || exit 1
     fi
 
 }
diff --git a/scripts/coccinelle/misc/memcpy-assign.cocci b/scripts/coccinelle/misc/memcpy-assign.cocci
new file mode 100644 (file)
index 0000000..afd058b
--- /dev/null
@@ -0,0 +1,103 @@
+//
+// Replace memcpy with struct assignment.
+//
+// Confidence: High
+// Copyright: (C) 2012 Peter Senna Tschudin, INRIA/LIP6.  GPLv2.
+// URL: http://coccinelle.lip6.fr/
+// Comments:
+// Options: --no-includes --include-headers
+
+virtual patch
+virtual report
+virtual context
+virtual org
+
+@r1 depends on !patch@
+identifier struct_name;
+struct struct_name to;
+struct struct_name from;
+struct struct_name *top;
+struct struct_name *fromp;
+position p;
+@@
+memcpy@p(\(&(to)\|top\), \(&(from)\|fromp\), \(sizeof(to)\|sizeof(from)\|sizeof(struct struct_name)\|sizeof(*top)\|sizeof(*fromp)\))
+
+@script:python depends on report@
+p << r1.p;
+@@
+coccilib.report.print_report(p[0],"Replace memcpy with struct assignment")
+
+@depends on context@
+position r1.p;
+@@
+*memcpy@p(...);
+
+@script:python depends on org@
+p << r1.p;
+@@
+cocci.print_main("Replace memcpy with struct assignment",p)
+
+@depends on patch@
+identifier struct_name;
+struct struct_name to;
+struct struct_name from;
+@@
+(
+-memcpy(&(to), &(from), sizeof(to));
++to = from;
+|
+-memcpy(&(to), &(from), sizeof(from));
++to = from;
+|
+-memcpy(&(to), &(from), sizeof(struct struct_name));
++to = from;
+)
+
+@depends on patch@
+identifier struct_name;
+struct struct_name to;
+struct struct_name *from;
+@@
+(
+-memcpy(&(to), from, sizeof(to));
++to = *from;
+|
+-memcpy(&(to), from, sizeof(*from));
++to = *from;
+|
+-memcpy(&(to), from, sizeof(struct struct_name));
++to = *from;
+)
+
+@depends on patch@
+identifier struct_name;
+struct struct_name *to;
+struct struct_name from;
+@@
+(
+-memcpy(to, &(from), sizeof(*to));
++ *to = from;
+|
+-memcpy(to, &(from), sizeof(from));
++ *to = from;
+|
+-memcpy(to, &(from), sizeof(struct struct_name));
++ *to = from;
+)
+
+@depends on patch@
+identifier struct_name;
+struct struct_name *to;
+struct struct_name *from;
+@@
+(
+-memcpy(to, from, sizeof(*to));
++ *to = *from;
+|
+-memcpy(to, from, sizeof(*from));
++ *to = *from;
+|
+-memcpy(to, from, sizeof(struct struct_name));
++ *to = *from;
+)
+
diff --git a/scripts/coccinelle/misc/orplus.cocci b/scripts/coccinelle/misc/orplus.cocci
new file mode 100644 (file)
index 0000000..4a28cef
--- /dev/null
@@ -0,0 +1,55 @@
+/// Check for constants that are added but are used elsewhere as bitmasks
+/// The results should be checked manually to ensure that the nonzero
+/// bits in the two constants are actually disjoint.
+///
+// Confidence: Moderate
+// Copyright: (C) 2013 Julia Lawall, INRIA/LIP6.  GPLv2.
+// Copyright: (C) 2013 Gilles Muller, INRIA/LIP6.  GPLv2.
+// URL: http://coccinelle.lip6.fr/
+// Comments:
+// Options: -no_includes -include_headers
+
+virtual org
+virtual report
+virtual context
+
+@r@
+constant c;
+identifier i;
+expression e;
+@@
+
+(
+e | c@i
+|
+e & c@i
+|
+e |= c@i
+|
+e &= c@i
+)
+
+@s@
+constant r.c,c1;
+identifier i1;
+position p;
+@@
+
+(
+ c1 + c - 1
+|
+*c1@i1 +@p c
+)
+
+@script:python depends on org@
+p << s.p;
+@@
+
+cocci.print_main("sum of probable bitmasks, consider |",p)
+
+@script:python depends on report@
+p << s.p;
+@@
+
+msg = "WARNING: sum of probable bitmasks, consider |"
+coccilib.report.print_report(p[0],msg)
diff --git a/scripts/coccinelle/misc/semicolon.cocci b/scripts/coccinelle/misc/semicolon.cocci
new file mode 100644 (file)
index 0000000..a47eba2
--- /dev/null
@@ -0,0 +1,83 @@
+///
+/// Removes unneeded semicolon.
+///
+// Confidence: Moderate
+// Copyright: (C) 2012 Peter Senna Tschudin, INRIA/LIP6.  GPLv2.
+// URL: http://coccinelle.lip6.fr/
+// Comments: Some false positives on empty default cases in switch statements.
+// Options: --no-includes --include-headers
+
+virtual patch
+virtual report
+virtual context
+virtual org
+
+@r_default@
+position p;
+@@
+switch (...)
+{
+default: ...;@p
+}
+
+@r_case@
+position p;
+@@
+(
+switch (...)
+{
+case ...:;@p
+}
+|
+switch (...)
+{
+case ...:...
+case ...:;@p
+}
+|
+switch (...)
+{
+case ...:...
+case ...:
+case ...:;@p
+}
+)
+
+@r1@
+statement S;
+position p1;
+position p != {r_default.p, r_case.p};
+identifier label;
+@@
+(
+label:;
+|
+S@p1;@p
+)
+
+@script:python@
+p << r1.p;
+p1 << r1.p1;
+@@
+if p[0].line != p1[0].line_end:
+       cocci.include_match(False)
+
+@depends on patch@
+position r1.p;
+@@
+-;@p
+
+@script:python depends on report@
+p << r1.p;
+@@
+coccilib.report.print_report(p[0],"Unneeded semicolon")
+
+@depends on context@
+position r1.p;
+@@
+*;@p
+
+@script:python depends on org@
+p << r1.p;
+@@
+cocci.print_main("Unneeded semicolon",p)
index 2ae4817..122599b 100755 (executable)
@@ -2,16 +2,36 @@
 #
 # A depmod wrapper used by the toplevel Makefile
 
-if test $# -ne 2; then
-       echo "Usage: $0 /sbin/depmod <kernelrelease>" >&2
+if test $# -ne 3; then
+       echo "Usage: $0 /sbin/depmod <kernelrelease> <symbolprefix>" >&2
        exit 1
 fi
 DEPMOD=$1
 KERNELRELEASE=$2
+SYMBOL_PREFIX=$3
 
 if ! test -r System.map -a -x "$DEPMOD"; then
        exit 0
 fi
+
+# older versions of depmod don't support -P <symbol-prefix>
+# support was added in module-init-tools 3.13
+if test -n "$SYMBOL_PREFIX"; then
+       release=$("$DEPMOD" --version)
+       package=$(echo "$release" | cut -d' ' -f 1)
+       if test "$package" = "module-init-tools"; then
+               version=$(echo "$release" | cut -d' ' -f 2)
+               later=$(printf '%s\n' "$version" "3.13" | sort -V | tail -n 1)
+               if test "$later" != "$version"; then
+                       # module-init-tools < 3.13, drop the symbol prefix
+                       SYMBOL_PREFIX=""
+               fi
+       fi
+       if test -n "$SYMBOL_PREFIX"; then
+               SYMBOL_PREFIX="-P $SYMBOL_PREFIX"
+       fi
+fi
+
 # older versions of depmod require the version string to start with three
 # numbers, so we cheat with a symlink here
 depmod_hack_needed=true
@@ -34,7 +54,7 @@ set -- -ae -F System.map
 if test -n "$INSTALL_MOD_PATH"; then
        set -- "$@" -b "$INSTALL_MOD_PATH"
 fi
-"$DEPMOD" "$@" "$KERNELRELEASE"
+"$DEPMOD" "$@" "$KERNELRELEASE" $SYMBOL_PREFIX
 ret=$?
 
 if $depmod_hack_needed; then
index 3091794..231b475 100644 (file)
@@ -11,6 +11,9 @@ else
 Kconfig := Kconfig
 endif
 
+# We need this, in case the user has it in its environment
+unexport CONFIG_
+
 xconfig: $(obj)/qconf
        $< $(Kconfig)
 
index 4da3b4a..e39fcd8 100644 (file)
@@ -36,6 +36,7 @@ enum input_mode {
 } input_mode = oldaskconfig;
 
 static int indent = 1;
+static int tty_stdio;
 static int valid_stdin = 1;
 static int sync_kconfig;
 static int conf_cnt;
@@ -108,6 +109,8 @@ static int conf_askvalue(struct symbol *sym, const char *def)
        case oldaskconfig:
                fflush(stdout);
                xfgets(line, 128, stdin);
+               if (!tty_stdio)
+                       printf("\n");
                return 1;
        default:
                break;
@@ -495,6 +498,8 @@ int main(int ac, char **av)
        bindtextdomain(PACKAGE, LOCALEDIR);
        textdomain(PACKAGE);
 
+       tty_stdio = isatty(0) && isatty(1) && isatty(2);
+
        while ((opt = getopt_long(ac, av, "", long_opts, NULL)) != -1) {
                input_mode = (enum input_mode)opt;
                switch (opt) {
@@ -621,7 +626,7 @@ int main(int ac, char **av)
                                return 1;
                        }
                }
-               valid_stdin = isatty(0) && isatty(1) && isatty(2);
+               valid_stdin = tty_stdio;
        }
 
        switch (input_mode) {
index 290ce41..d662652 100644 (file)
@@ -13,7 +13,7 @@
 
 struct expr *expr_alloc_symbol(struct symbol *sym)
 {
-       struct expr *e = calloc(1, sizeof(*e));
+       struct expr *e = xcalloc(1, sizeof(*e));
        e->type = E_SYMBOL;
        e->left.sym = sym;
        return e;
@@ -21,7 +21,7 @@ struct expr *expr_alloc_symbol(struct symbol *sym)
 
 struct expr *expr_alloc_one(enum expr_type type, struct expr *ce)
 {
-       struct expr *e = calloc(1, sizeof(*e));
+       struct expr *e = xcalloc(1, sizeof(*e));
        e->type = type;
        e->left.expr = ce;
        return e;
@@ -29,7 +29,7 @@ struct expr *expr_alloc_one(enum expr_type type, struct expr *ce)
 
 struct expr *expr_alloc_two(enum expr_type type, struct expr *e1, struct expr *e2)
 {
-       struct expr *e = calloc(1, sizeof(*e));
+       struct expr *e = xcalloc(1, sizeof(*e));
        e->type = type;
        e->left.expr = e1;
        e->right.expr = e2;
@@ -38,7 +38,7 @@ struct expr *expr_alloc_two(enum expr_type type, struct expr *e1, struct expr *e
 
 struct expr *expr_alloc_comp(enum expr_type type, struct symbol *s1, struct symbol *s2)
 {
-       struct expr *e = calloc(1, sizeof(*e));
+       struct expr *e = xcalloc(1, sizeof(*e));
        e->type = type;
        e->left.sym = s1;
        e->right.sym = s2;
@@ -66,7 +66,7 @@ struct expr *expr_copy(const struct expr *org)
        if (!org)
                return NULL;
 
-       e = malloc(sizeof(*org));
+       e = xmalloc(sizeof(*org));
        memcpy(e, org, sizeof(*org));
        switch (org->type) {
        case E_SYMBOL:
index adc2306..f2bee70 100644 (file)
@@ -10,6 +10,7 @@
 #  include <config.h>
 #endif
 
+#include <stdlib.h>
 #include "lkc.h"
 #include "images.c"
 
@@ -22,7 +23,6 @@
 #include <string.h>
 #include <unistd.h>
 #include <time.h>
-#include <stdlib.h>
 
 //#define DEBUG
 
index c18f2bd..f8aee5f 100644 (file)
@@ -39,6 +39,12 @@ extern "C" {
 #ifndef CONFIG_
 #define CONFIG_ "CONFIG_"
 #endif
+static inline const char *CONFIG_prefix(void)
+{
+       return getenv( "CONFIG_" ) ?: CONFIG_;
+}
+#undef CONFIG_
+#define CONFIG_ CONFIG_prefix()
 
 #define TF_COMMAND     0x0001
 #define TF_PARAM       0x0002
@@ -116,6 +122,8 @@ void menu_set_type(int type);
 /* util.c */
 struct file *file_lookup(const char *name);
 int file_write_dep(const char *name);
+void *xmalloc(size_t size);
+void *xcalloc(size_t nmemb, size_t size);
 
 struct gstr {
        size_t len;
index c8e8a71..8078813 100644 (file)
@@ -21,6 +21,7 @@ ccflags()
 {
        if [ -f /usr/include/ncursesw/curses.h ]; then
                echo '-I/usr/include/ncursesw -DCURSES_LOC="<ncursesw/curses.h>"'
+               echo ' -DNCURSES_WIDECHAR=1'
        elif [ -f /usr/include/ncurses/ncurses.h ]; then
                echo '-I/usr/include/ncurses -DCURSES_LOC="<ncurses.h>"'
        elif [ -f /usr/include/ncurses/curses.h ]; then
index ee17a52..307022a 100644 (file)
@@ -221,7 +221,6 @@ int dialog_menu(const char *title, const char *prompt,
                const void *selected, int *s_scroll);
 int dialog_checklist(const char *title, const char *prompt, int height,
                     int width, int list_height);
-extern char dialog_input_result[];
 int dialog_inputbox(const char *title, const char *prompt, int height,
                    int width, const char *init);
 
index dd8e587..21404a0 100644 (file)
@@ -45,7 +45,8 @@ int dialog_inputbox(const char *title, const char *prompt, int height, int width
                     const char *init)
 {
        int i, x, y, box_y, box_x, box_width;
-       int input_x = 0, scroll = 0, key = 0, button = -1;
+       int input_x = 0, key = 0, button = -1;
+       int show_x, len, pos;
        char *instr = dialog_input_result;
        WINDOW *dialog;
 
@@ -97,14 +98,17 @@ do_resize:
        wmove(dialog, box_y, box_x);
        wattrset(dialog, dlg.inputbox.atr);
 
-       input_x = strlen(instr);
+       len = strlen(instr);
+       pos = len;
 
-       if (input_x >= box_width) {
-               scroll = input_x - box_width + 1;
+       if (len >= box_width) {
+               show_x = len - box_width + 1;
                input_x = box_width - 1;
                for (i = 0; i < box_width - 1; i++)
-                       waddch(dialog, instr[scroll + i]);
+                       waddch(dialog, instr[show_x + i]);
        } else {
+               show_x = 0;
+               input_x = len;
                waddstr(dialog, instr);
        }
 
@@ -121,45 +125,104 @@ do_resize:
                        case KEY_UP:
                        case KEY_DOWN:
                                break;
-                       case KEY_LEFT:
-                               continue;
-                       case KEY_RIGHT:
-                               continue;
                        case KEY_BACKSPACE:
                        case 127:
-                               if (input_x || scroll) {
+                               if (pos) {
                                        wattrset(dialog, dlg.inputbox.atr);
-                                       if (!input_x) {
-                                               scroll = scroll < box_width - 1 ? 0 : scroll - (box_width - 1);
-                                               wmove(dialog, box_y, box_x);
-                                               for (i = 0; i < box_width; i++)
-                                                       waddch(dialog,
-                                                              instr[scroll + input_x + i] ?
-                                                              instr[scroll + input_x + i] : ' ');
-                                               input_x = strlen(instr) - scroll;
+                                       if (input_x == 0) {
+                                               show_x--;
                                        } else
                                                input_x--;
-                                       instr[scroll + input_x] = '\0';
-                                       mvwaddch(dialog, box_y, input_x + box_x, ' ');
+
+                                       if (pos < len) {
+                                               for (i = pos - 1; i < len; i++) {
+                                                       instr[i] = instr[i+1];
+                                               }
+                                       }
+
+                                       pos--;
+                                       len--;
+                                       instr[len] = '\0';
+                                       wmove(dialog, box_y, box_x);
+                                       for (i = 0; i < box_width; i++) {
+                                               if (!instr[show_x + i]) {
+                                                       waddch(dialog, ' ');
+                                                       break;
+                                               }
+                                               waddch(dialog, instr[show_x + i]);
+                                       }
                                        wmove(dialog, box_y, input_x + box_x);
                                        wrefresh(dialog);
                                }
                                continue;
+                       case KEY_LEFT:
+                               if (pos > 0) {
+                                       if (input_x > 0) {
+                                               wmove(dialog, box_y, --input_x + box_x);
+                                       } else if (input_x == 0) {
+                                               show_x--;
+                                               wmove(dialog, box_y, box_x);
+                                               for (i = 0; i < box_width; i++) {
+                                                       if (!instr[show_x + i]) {
+                                                               waddch(dialog, ' ');
+                                                               break;
+                                                       }
+                                                       waddch(dialog, instr[show_x + i]);
+                                               }
+                                               wmove(dialog, box_y, box_x);
+                                       }
+                                       pos--;
+                               }
+                               continue;
+                       case KEY_RIGHT:
+                               if (pos < len) {
+                                       if (input_x < box_width - 1) {
+                                               wmove(dialog, box_y, ++input_x + box_x);
+                                       } else if (input_x == box_width - 1) {
+                                               show_x++;
+                                               wmove(dialog, box_y, box_x);
+                                               for (i = 0; i < box_width; i++) {
+                                                       if (!instr[show_x + i]) {
+                                                               waddch(dialog, ' ');
+                                                               break;
+                                                       }
+                                                       waddch(dialog, instr[show_x + i]);
+                                               }
+                                               wmove(dialog, box_y, input_x + box_x);
+                                       }
+                                       pos++;
+                               }
+                               continue;
                        default:
                                if (key < 0x100 && isprint(key)) {
-                                       if (scroll + input_x < MAX_LEN) {
+                                       if (len < MAX_LEN) {
                                                wattrset(dialog, dlg.inputbox.atr);
-                                               instr[scroll + input_x] = key;
-                                               instr[scroll + input_x + 1] = '\0';
+                                               if (pos < len) {
+                                                       for (i = len; i > pos; i--)
+                                                               instr[i] = instr[i-1];
+                                                       instr[pos] = key;
+                                               } else {
+                                                       instr[len] = key;
+                                               }
+                                               pos++;
+                                               len++;
+                                               instr[len] = '\0';
+
                                                if (input_x == box_width - 1) {
-                                                       scroll++;
-                                                       wmove(dialog, box_y, box_x);
-                                                       for (i = 0; i < box_width - 1; i++)
-                                                               waddch(dialog, instr [scroll + i]);
+                                                       show_x++;
                                                } else {
-                                                       wmove(dialog, box_y, input_x++ + box_x);
-                                                       waddch(dialog, key);
+                                                       input_x++;
+                                               }
+
+                                               wmove(dialog, box_y, box_x);
+                                               for (i = 0; i < box_width; i++) {
+                                                       if (!instr[show_x + i]) {
+                                                               waddch(dialog, ' ');
+                                                               break;
+                                                       }
+                                                       waddch(dialog, instr[show_x + i]);
                                                }
+                                               wmove(dialog, box_y, input_x + box_x);
                                                wrefresh(dialog);
                                        } else
                                                flash();        /* Alarm user about overflow */
index 1d60473..48d382e 100644 (file)
@@ -26,7 +26,7 @@
  *
  *    *)  A bugfix for the Page-Down problem
  *
- *    *)  Formerly when I used Page Down and Page Up, the cursor would be set 
+ *    *)  Formerly when I used Page Down and Page Up, the cursor would be set
  *        to the first position in the menu box.  Now lxdialog is a bit
  *        smarter and works more like other menu systems (just have a look at
  *        it).
@@ -154,12 +154,14 @@ static void print_arrows(WINDOW * win, int item_no, int scroll, int y, int x,
  */
 static void print_buttons(WINDOW * win, int height, int width, int selected)
 {
-       int x = width / 2 - 16;
+       int x = width / 2 - 28;
        int y = height - 2;
 
        print_button(win, gettext("Select"), y, x, selected == 0);
        print_button(win, gettext(" Exit "), y, x + 12, selected == 1);
        print_button(win, gettext(" Help "), y, x + 24, selected == 2);
+       print_button(win, gettext(" Save "), y, x + 36, selected == 3);
+       print_button(win, gettext(" Load "), y, x + 48, selected == 4);
 
        wmove(win, y, x + 1 + 12 * selected);
        wrefresh(win);
@@ -372,7 +374,7 @@ do_resize:
                case TAB:
                case KEY_RIGHT:
                        button = ((key == KEY_LEFT ? --button : ++button) < 0)
-                           ? 2 : (button > 2 ? 0 : button);
+                           ? 4 : (button > 4 ? 0 : button);
 
                        print_buttons(dialog, height, width, button);
                        wrefresh(menu);
@@ -399,17 +401,17 @@ do_resize:
                                return 2;
                        case 's':
                        case 'y':
-                               return 3;
+                               return 5;
                        case 'n':
-                               return 4;
+                               return 6;
                        case 'm':
-                               return 5;
+                               return 7;
                        case ' ':
-                               return 6;
+                               return 8;
                        case '/':
-                               return 7;
+                               return 9;
                        case 'z':
-                               return 8;
+                               return 10;
                        case '\n':
                                return button;
                        }
index 53975cf..566288a 100644 (file)
@@ -280,6 +280,7 @@ static struct menu *current_menu;
 static int child_count;
 static int single_menu_mode;
 static int show_all_options;
+static int save_and_exit;
 
 static void conf(struct menu *menu, struct menu *active_menu);
 static void conf_choice(struct menu *menu);
@@ -348,15 +349,19 @@ static void search_conf(void)
 {
        struct symbol **sym_arr;
        struct gstr res;
+       struct gstr title;
        char *dialog_input;
        int dres, vscroll = 0, hscroll = 0;
        bool again;
 
+       title = str_new();
+       str_printf( &title, _("Enter %s (sub)string to search for "
+                             "(with or without \"%s\")"), CONFIG_, CONFIG_);
+
 again:
        dialog_clear();
        dres = dialog_inputbox(_("Search Configuration Parameter"),
-                             _("Enter " CONFIG_ " (sub)string to search for "
-                               "(with or without \"" CONFIG_ "\")"),
+                             str_get(&title),
                              10, 75, "");
        switch (dres) {
        case 0:
@@ -365,6 +370,7 @@ again:
                show_helptext(_("Search Configuration"), search_help);
                goto again;
        default:
+               str_free(&title);
                return;
        }
 
@@ -398,6 +404,7 @@ again:
                str_free(&res);
        } while (again);
        free(sym_arr);
+       str_free(&title);
 }
 
 static void build_conf(struct menu *menu)
@@ -592,14 +599,6 @@ static void conf(struct menu *menu, struct menu *active_menu)
                build_conf(menu);
                if (!child_count)
                        break;
-               if (menu == &rootmenu) {
-                       item_make("--- ");
-                       item_set_tag(':');
-                       item_make(_("    Load an Alternate Configuration File"));
-                       item_set_tag('L');
-                       item_make(_("    Save an Alternate Configuration File"));
-                       item_set_tag('S');
-               }
                dialog_clear();
                res = dialog_menu(prompt ? _(prompt) : _("Main Menu"),
                                  _(menu_instructions),
@@ -636,12 +635,6 @@ static void conf(struct menu *menu, struct menu *active_menu)
                        case 's':
                                conf_string(submenu);
                                break;
-                       case 'L':
-                               conf_load();
-                               break;
-                       case 'S':
-                               conf_save();
-                               break;
                        }
                        break;
                case 2:
@@ -651,6 +644,12 @@ static void conf(struct menu *menu, struct menu *active_menu)
                                show_helptext(_("README"), _(mconf_readme));
                        break;
                case 3:
+                       conf_save();
+                       break;
+               case 4:
+                       conf_load();
+                       break;
+               case 5:
                        if (item_is_tag('t')) {
                                if (sym_set_tristate_value(sym, yes))
                                        break;
@@ -658,24 +657,24 @@ static void conf(struct menu *menu, struct menu *active_menu)
                                        show_textbox(NULL, setmod_text, 6, 74);
                        }
                        break;
-               case 4:
+               case 6:
                        if (item_is_tag('t'))
                                sym_set_tristate_value(sym, no);
                        break;
-               case 5:
+               case 7:
                        if (item_is_tag('t'))
                                sym_set_tristate_value(sym, mod);
                        break;
-               case 6:
+               case 8:
                        if (item_is_tag('t'))
                                sym_toggle_tristate_value(sym);
                        else if (item_is_tag('m'))
                                conf(submenu, NULL);
                        break;
-               case 7:
+               case 9:
                        search_conf();
                        break;
-               case 8:
+               case 10:
                        show_all_options = !show_all_options;
                        break;
                }
@@ -702,6 +701,17 @@ static void show_helptext(const char *title, const char *text)
        show_textbox(title, text, 0, 0);
 }
 
+static void conf_message_callback(const char *fmt, va_list ap)
+{
+       char buf[PATH_MAX+1];
+
+       vsnprintf(buf, sizeof(buf), fmt, ap);
+       if (save_and_exit)
+               printf("%s", buf);
+       else
+               show_textbox(NULL, buf, 6, 60);
+}
+
 static void show_help(struct menu *menu)
 {
        struct gstr help = str_new();
@@ -870,6 +880,7 @@ static int handle_exit(void)
 {
        int res;
 
+       save_and_exit = 1;
        dialog_clear();
        if (conf_get_changed())
                res = dialog_yesno(NULL,
@@ -941,6 +952,7 @@ int main(int ac, char **av)
        }
 
        set_config_filename(conf_get_configname());
+       conf_set_message_callback(conf_message_callback);
        do {
                conf(&rootmenu, NULL);
                res = handle_exit();
index e98a05c..f3bffa3 100644 (file)
@@ -48,7 +48,7 @@ void menu_add_entry(struct symbol *sym)
 {
        struct menu *menu;
 
-       menu = malloc(sizeof(*menu));
+       menu = xmalloc(sizeof(*menu));
        memset(menu, 0, sizeof(*menu));
        menu->sym = sym;
        menu->parent = current_menu;
@@ -531,7 +531,7 @@ static void get_prompt_str(struct gstr *r, struct property *prop,
                        location = menu;
        }
        if (head && location) {
-               jump = malloc(sizeof(struct jump_key));
+               jump = xmalloc(sizeof(struct jump_key));
 
                if (menu_is_visible(prop->menu)) {
                        /*
index 974d5cb..05274fc 100755 (executable)
@@ -32,11 +32,13 @@ usage() {
        echo "  -m    only merge the fragments, do not execute the make command"
        echo "  -n    use allnoconfig instead of alldefconfig"
        echo "  -r    list redundant entries when merging fragments"
+       echo "  -O    dir to put generated output files"
 }
 
 MAKE=true
 ALLTARGET=alldefconfig
 WARNREDUN=false
+OUTPUT=.
 
 while true; do
        case $1 in
@@ -59,6 +61,16 @@ while true; do
                shift
                continue
                ;;
+       "-O")
+               if [ -d $2 ];then
+                       OUTPUT=$(echo $2 | sed 's/\/*$//')
+               else
+                       echo "output directory $2 does not exist" 1>&2
+                       exit 1
+               fi
+               shift 2
+               continue
+               ;;
        *)
                break
                ;;
@@ -100,9 +112,9 @@ for MERGE_FILE in $MERGE_LIST ; do
 done
 
 if [ "$MAKE" = "false" ]; then
-       cp $TMP_FILE .config
+       cp $TMP_FILE $OUTPUT/.config
        echo "#"
-       echo "# merged configuration written to .config (needs make)"
+       echo "# merged configuration written to $OUTPUT/.config (needs make)"
        echo "#"
        clean_up
        exit
@@ -111,14 +123,14 @@ fi
 # Use the merged file as the starting point for:
 # alldefconfig: Fills in any missing symbols with Kconfig default
 # allnoconfig: Fills in any missing symbols with # CONFIG_* is not set
-make KCONFIG_ALLCONFIG=$TMP_FILE $ALLTARGET
+make KCONFIG_ALLCONFIG=$TMP_FILE O=$OUTPUT $ALLTARGET
 
 
 # Check all specified config values took (might have missed-dependency issues)
 for CFG in $(sed -n "$SED_CONFIG_EXP" $TMP_FILE); do
 
        REQUESTED_VAL=$(grep -w -e "$CFG" $TMP_FILE)
-       ACTUAL_VAL=$(grep -w -e "$CFG" .config)
+       ACTUAL_VAL=$(grep -w -e "$CFG" $OUTPUT/.config)
        if [ "x$REQUESTED_VAL" != "x$ACTUAL_VAL" ] ; then
                echo "Value requested for $CFG not in final .config"
                echo "Requested value:  $REQUESTED_VAL"
index 87d4b15..dbf31ed 100644 (file)
  */
 #define _GNU_SOURCE
 #include <string.h>
+#include <stdlib.h>
 
 #include "lkc.h"
 #include "nconf.h"
 #include <ctype.h>
 
-static const char nconf_readme[] = N_(
-"Overview\n"
-"--------\n"
-"This interface let you select features and parameters for the build.\n"
-"Features can either be built-in, modularized, or ignored. Parameters\n"
-"must be entered in as decimal or hexadecimal numbers or text.\n"
+static const char nconf_global_help[] = N_(
+"Help windows\n"
+"------------\n"
+"o  Global help:  Unless in a data entry window, pressing <F1> will give \n"
+"   you the global help window, which you are just reading.\n"
 "\n"
-"Menu items beginning with following braces represent features that\n"
-"  [ ] can be built in or removed\n"
-"  < > can be built in, modularized or removed\n"
-"  { } can be built in or modularized (selected by other feature)\n"
-"  - - are selected by other feature,\n"
-"  XXX cannot be selected. Use Symbol Info to find out why,\n"
-"while *, M or whitespace inside braces means to build in, build as\n"
-"a module or to exclude the feature respectively.\n"
+"o  A short version of the global help is available by pressing <F3>.\n"
 "\n"
-"To change any of these features, highlight it with the cursor\n"
-"keys and press <Y> to build it in, <M> to make it a module or\n"
-"<N> to removed it.  You may also press the <Space Bar> to cycle\n"
-"through the available options (ie. Y->N->M->Y).\n"
+"o  Local help:  To get help related to the current menu entry, use any\n"
+"   of <?> <h>, or if in a data entry window then press <F1>.\n"
 "\n"
-"Some additional keyboard hints:\n"
 "\n"
-"Menus\n"
-"----------\n"
-"o  Use the Up/Down arrow keys (cursor keys) to highlight the item\n"
-"   you wish to change use <Enter> or <Space>. Goto submenu by \n"
-"   pressing <Enter> of <right-arrow>. Use <Esc> or <left-arrow> to go back.\n"
-"   Submenus are designated by \"--->\".\n"
-"\n"
-"   Searching: pressing '/' triggers interactive search mode.\n"
-"              nconfig performs a case insensitive search for the string\n"
-"              in the menu prompts (no regex support).\n"
-"              Pressing the up/down keys highlights the previous/next\n"
-"              matching item. Backspace removes one character from the\n"
-"              match string. Pressing either '/' again or ESC exits\n"
-"              search mode. All other keys behave normally.\n"
+"Menu entries\n"
+"------------\n"
+"This interface lets you select features and parameters for the kernel\n"
+"build.  Kernel features can either be built-in, modularized, or removed.\n"
+"Parameters must be entered as text or decimal or hexadecimal numbers.\n"
 "\n"
-"   You may also use the <PAGE UP> and <PAGE DOWN> keys to scroll\n"
-"   unseen options into view.\n"
+"Menu entries beginning with following braces represent features that\n"
+"  [ ]  can be built in or removed\n"
+"  < >  can be built in, modularized or removed\n"
+"  { }  can be built in or modularized, are selected by another feature\n"
+"  - -  are selected by another feature\n"
+"  XXX  cannot be selected.  Symbol Info <F2> tells you why.\n"
+"*, M or whitespace inside braces means to build in, build as a module\n"
+"or to exclude the feature respectively.\n"
 "\n"
-"o  To exit a menu use the just press <ESC> <F5> <F8> or <left-arrow>.\n"
+"To change any of these features, highlight it with the movement keys\n"
+"listed below and press <y> to build it in, <m> to make it a module or\n"
+"<n> to remove it.  You may press the <Space> key to cycle through the\n"
+"available options.\n"
 "\n"
-"o  To get help with an item, press <F1>\n"
-"   Shortcut: Press <h> or <?>.\n"
+"A trailing \"--->\" designates a submenu.\n"
 "\n"
 "\n"
-"Radiolists  (Choice lists)\n"
-"-----------\n"
-"o  Use the cursor keys to select the option you wish to set and press\n"
-"   <S> or the <SPACE BAR>.\n"
+"Menu navigation keys\n"
+"----------------------------------------------------------------------\n"
+"Linewise up                 <Up>\n"
+"Linewise down               <Down>\n"
+"Pagewise up                 <Page Up>\n"
+"Pagewise down               <Page Down>\n"
+"First entry                 <Home>\n"
+"Last entry                  <End>\n"
+"Enter a submenu             <Right>  <Enter>\n"
+"Go back to parent menu      <Left>   <Esc>  <F5>\n"
+"Close a help window         <Enter>  <Esc>  <F5>\n"
+"Close entry window, apply   <Enter>\n"
+"Close entry window, forget  <Esc>  <F5>\n"
+"Start incremental, case-insensitive search for STRING in menu entries,\n"
+"    no regex support, STRING is displayed in upper left corner\n"
+"                            </>STRING\n"
+"    Remove last character   <Backspace>\n"
+"    Jump to next hit        <Down>\n"
+"    Jump to previous hit    <Up>\n"
+"Exit menu search mode       </>  <Esc>\n"
+"Search for configuration variables with or without leading CONFIG_\n"
+"                            <F8>RegExpr<Enter>\n"
+"Verbose search help         <F8><F1>\n"
+"----------------------------------------------------------------------\n"
 "\n"
-"   Shortcut: Press the first letter of the option you wish to set then\n"
-"             press <S> or <SPACE BAR>.\n"
+"Unless in a data entry window, key <1> may be used instead of <F1>,\n"
+"<2> instead of <F2>, etc.\n"
 "\n"
-"o  To see available help for the item, press <F1>\n"
-"   Shortcut: Press <H> or <?>.\n"
 "\n"
+"Radiolist (Choice list)\n"
+"-----------------------\n"
+"Use the movement keys listed above to select the option you wish to set\n"
+"and press <Space>.\n"
 "\n"
-"Data Entry\n"
-"-----------\n"
-"o  Enter the requested information and press <ENTER>\n"
-"   If you are entering hexadecimal values, it is not necessary to\n"
-"   add the '0x' prefix to the entry.\n"
 "\n"
-"o  For help, press <F1>.\n"
+"Data entry\n"
+"----------\n"
+"Enter the requested information and press <Enter>.  Hexadecimal values\n"
+"may be entered without the \"0x\" prefix.\n"
 "\n"
 "\n"
-"Text Box    (Help Window)\n"
-"--------\n"
-"o  Use the cursor keys to scroll up/down/left/right.  The VI editor\n"
-"   keys h,j,k,l function here as do <u>, <d> and <SPACE BAR> for\n"
-"   those who are familiar with less and lynx.\n"
+"Text Box (Help Window)\n"
+"----------------------\n"
+"Use movement keys as listed in table above.\n"
 "\n"
-"o  Press <Enter>, <F1>, <F5>, <F9>, <q> or <Esc> to exit.\n"
+"Press any of <Enter> <Esc> <q> <F5> <F9> to exit.\n"
 "\n"
 "\n"
-"Alternate Configuration Files\n"
+"Alternate configuration files\n"
 "-----------------------------\n"
-"nconfig supports the use of alternate configuration files for\n"
-"those who, for various reasons, find it necessary to switch\n"
-"between different configurations.\n"
+"nconfig supports switching between different configurations.\n"
+"Press <F6> to save your current configuration.  Press <F7> and enter\n"
+"a file name to load a previously saved configuration.\n"
 "\n"
-"At the end of the main menu you will find two options.  One is\n"
-"for saving the current configuration to a file of your choosing.\n"
-"The other option is for loading a previously saved alternate\n"
-"configuration.\n"
 "\n"
-"Even if you don't use alternate configuration files, but you\n"
-"find during a nconfig session that you have completely messed\n"
-"up your settings, you may use the \"Load Alternate...\" option to\n"
-"restore your previously saved settings from \".config\" without\n"
-"restarting nconfig.\n"
+"Terminal configuration\n"
+"----------------------\n"
+"If you use nconfig in a xterm window, make sure your TERM environment\n"
+"variable specifies a terminal configuration which supports at least\n"
+"16 colors.  Otherwise nconfig will look rather bad.\n"
 "\n"
-"Other information\n"
-"-----------------\n"
-"If you use nconfig in an XTERM window make sure you have your\n"
-"$TERM variable set to point to a xterm definition which supports color.\n"
-"Otherwise, nconfig will look rather bad.  nconfig will not\n"
-"display correctly in a RXVT window because rxvt displays only one\n"
-"intensity of color, bright.\n"
+"If the \"stty size\" command reports the current terminalsize correctly,\n"
+"nconfig will adapt to sizes larger than the traditional 80x25 \"standard\"\n"
+"and display longer menus properly.\n"
 "\n"
-"nconfig will display larger menus on screens or xterms which are\n"
-"set to display more than the standard 25 row by 80 column geometry.\n"
-"In order for this to work, the \"stty size\" command must be able to\n"
-"display the screen's current row and column geometry.  I STRONGLY\n"
-"RECOMMEND that you make sure you do NOT have the shell variables\n"
-"LINES and COLUMNS exported into your environment.  Some distributions\n"
-"export those variables via /etc/profile.  Some ncurses programs can\n"
-"become confused when those variables (LINES & COLUMNS) don't reflect\n"
-"the true screen size.\n"
 "\n"
-"Optional personality available\n"
-"------------------------------\n"
-"If you prefer to have all of the options listed in a single menu, rather\n"
-"than the default multimenu hierarchy, run the nconfig with NCONFIG_MODE\n"
-"environment variable set to single_menu. Example:\n"
+"Single menu mode\n"
+"----------------\n"
+"If you prefer to have all of the menu entries listed in a single menu,\n"
+"rather than the default multimenu hierarchy, run nconfig with\n"
+"NCONFIG_MODE environment variable set to single_menu.  Example:\n"
 "\n"
 "make NCONFIG_MODE=single_menu nconfig\n"
 "\n"
-"<Enter> will then unroll the appropriate category, or enfold it if it\n"
-"is already unrolled.\n"
+"<Enter> will then unfold the appropriate category, or fold it if it\n"
+"is already unfolded.  Folded menu entries will be designated by a\n"
+"leading \"++>\" and unfolded entries by a leading \"-->\".\n"
 "\n"
-"Note that this mode can eventually be a little more CPU expensive\n"
-"(especially with a larger number of unrolled categories) than the\n"
-"default mode.\n"
+"Note that this mode can eventually be a little more CPU expensive than\n"
+"the default mode, especially with a larger number of unfolded submenus.\n"
 "\n"),
 menu_no_f_instructions[] = N_(
-" You do not have function keys support. Please follow the\n"
-" following instructions:\n"
-" Arrow keys navigate the menu.\n"
-" <Enter> or <right-arrow> selects submenus --->.\n"
-" Capital Letters are hotkeys.\n"
-" Pressing <Y> includes, <N> excludes, <M> modularizes features.\n"
-" Pressing SpaceBar toggles between the above options.\n"
-" Press <Esc> or <left-arrow> to go back one menu,\n"
-" <?> or <h> for Help, </> for Search.\n"
-" <1> is interchangeable with <F1>, <2> with <F2>, etc.\n"
-" Legend: [*] built-in  [ ] excluded  <M> module  < > module capable.\n"
-" <Esc> always leaves the current window.\n"),
+"Legend:  [*] built-in  [ ] excluded  <M> module  < > module capable.\n"
+"Submenus are designated by a trailing \"--->\".\n"
+"\n"
+"Use the following keys to navigate the menus:\n"
+"Move up or down with <Up> and <Down>.\n"
+"Enter a submenu with <Enter> or <Right>.\n"
+"Exit a submenu to its parent menu with <Esc> or <Left>.\n"
+"Pressing <y> includes, <n> excludes, <m> modularizes features.\n"
+"Pressing <Space> cycles through the available options.\n"
+"To search for menu entries press </>.\n"
+"<Esc> always leaves the current window.\n"
+"\n"
+"You do not have function keys support.\n"
+"Press <1> instead of <F1>, <2> instead of <F2>, etc.\n"
+"For verbose global help use key <1>.\n"
+"For help related to the current menu entry press <?> or <h>.\n"),
 menu_instructions[] = N_(
-" Arrow keys navigate the menu.\n"
-" <Enter> or <right-arrow> selects submenus --->.\n"
-" Capital Letters are hotkeys.\n"
-" Pressing <Y> includes, <N> excludes, <M> modularizes features.\n"
-" Pressing SpaceBar toggles between the above options\n"
-" Press <Esc>, <F5> or <left-arrow> to go back one menu,\n"
-" <?>, <F1> or <h> for Help, </> for Search.\n"
-" <1> is interchangeable with <F1>, <2> with <F2>, etc.\n"
-" Legend: [*] built-in  [ ] excluded  <M> module  < > module capable.\n"
-" <Esc> always leaves the current window\n"),
+"Legend:  [*] built-in  [ ] excluded  <M> module  < > module capable.\n"
+"Submenus are designated by a trailing \"--->\".\n"
+"\n"
+"Use the following keys to navigate the menus:\n"
+"Move up or down with <Up> or <Down>.\n"
+"Enter a submenu with <Enter> or <Right>.\n"
+"Exit a submenu to its parent menu with <Esc> or <Left>.\n"
+"Pressing <y> includes, <n> excludes, <m> modularizes features.\n"
+"Pressing <Space> cycles through the available options.\n"
+"To search for menu entries press </>.\n"
+"<Esc> always leaves the current window.\n"
+"\n"
+"Pressing <1> may be used instead of <F1>, <2> instead of <F2>, etc.\n"
+"For verbose global help press <F1>.\n"
+"For help related to the current menu entry press <?> or <h>.\n"),
 radiolist_instructions[] = N_(
-" Use the arrow keys to navigate this window or\n"
-" press the hotkey of the item you wish to select\n"
-" followed by the <SPACE BAR>.\n"
-" Press <?>, <F1> or <h> for additional information about this option.\n"),
+"Press <Up>, <Down>, <Home> or <End> to navigate a radiolist, select\n"
+"with <Space>.\n"
+"For help related to the current entry press <?> or <h>.\n"
+"For global help press <F1>.\n"),
 inputbox_instructions_int[] = N_(
 "Please enter a decimal value.\n"
 "Fractions will not be accepted.\n"
-"Press <RETURN> to accept, <ESC> to cancel."),
+"Press <Enter> to apply, <Esc> to cancel."),
 inputbox_instructions_hex[] = N_(
 "Please enter a hexadecimal value.\n"
-"Press <RETURN> to accept, <ESC> to cancel."),
+"Press <Enter> to apply, <Esc> to cancel."),
 inputbox_instructions_string[] = N_(
 "Please enter a string value.\n"
-"Press <RETURN> to accept, <ESC> to cancel."),
+"Press <Enter> to apply, <Esc> to cancel."),
 setmod_text[] = N_(
-"This feature depends on another which\n"
-"has been configured as a module.\n"
-"As a result, this feature will be built as a module."),
+"This feature depends on another feature which has been configured as a\n"
+"module.  As a result, the current feature will be built as a module too."),
 load_config_text[] = N_(
 "Enter the name of the configuration file you wish to load.\n"
-"Accept the name shown to restore the configuration you\n"
-"last retrieved.  Leave blank to abort."),
+"Accept the name shown to restore the configuration you last\n"
+"retrieved.  Leave empty to abort."),
 load_config_help[] = N_(
-"\n"
 "For various reasons, one may wish to keep several different\n"
 "configurations available on a single machine.\n"
 "\n"
 "If you have saved a previous configuration in a file other than the\n"
-"default one, entering its name here will allow you to modify that\n"
-"configuration.\n"
+"default one, entering its name here will allow you to load and modify\n"
+"that configuration.\n"
 "\n"
-"If you are uncertain, then you have probably never used alternate\n"
-"configuration files.  You should therefor leave this blank to abort.\n"),
+"Leave empty to abort.\n"),
 save_config_text[] = N_(
 "Enter a filename to which this configuration should be saved\n"
-"as an alternate.  Leave blank to abort."),
+"as an alternate.  Leave empty to abort."),
 save_config_help[] = N_(
-"\n"
-"For various reasons, one may wish to keep different configurations\n"
-"available on a single machine.\n"
+"For various reasons, one may wish to keep several different\n"
+"configurations available on a single machine.\n"
 "\n"
 "Entering a file name here will allow you to later retrieve, modify\n"
 "and use the current configuration as an alternate to whatever\n"
 "configuration options you have selected at that time.\n"
 "\n"
-"If you are uncertain what all this means then you should probably\n"
-"leave this blank.\n"),
+"Leave empty to abort.\n"),
 search_help[] = N_(
-"\n"
-"Search for symbols and display their relations. Regular expressions\n"
-"are allowed.\n"
-"Example: search for \"^FOO\"\n"
+"Search for symbols (configuration variable names CONFIG_*) and display\n"
+"their relations.  Regular expressions are supported.\n"
+"Example:  Search for \"^FOO\".\n"
 "Result:\n"
 "-----------------------------------------------------------------\n"
 "Symbol: FOO [ = m]\n"
@@ -229,26 +222,26 @@ search_help[] = N_(
 "Selects: LIBCRC32\n"
 "Selected by: BAR\n"
 "-----------------------------------------------------------------\n"
-"o The line 'Prompt:' shows the text used in the menu structure for\n"
-"  this symbol\n"
-"o The 'Defined at' line tell at what file / line number the symbol\n"
-"  is defined\n"
-"o The 'Depends on:' line tell what symbols needs to be defined for\n"
-"  this symbol to be visible in the menu (selectable)\n"
-"o The 'Location:' lines tell where in the menu structure this symbol\n"
-"  is located\n"
-"    A location followed by a [ = y] indicate that this is a selectable\n"
-"    menu item - and current value is displayed inside brackets.\n"
-"o The 'Selects:' line tell what symbol will be automatically\n"
-"  selected if this symbol is selected (y or m)\n"
-"o The 'Selected by' line tell what symbol has selected this symbol\n"
+"o  The line 'Prompt:' shows the text displayed for this symbol in\n"
+"   the menu hierarchy.\n"
+"o  The 'Defined at' line tells at what file / line number the symbol is\n"
+"   defined.\n"
+"o  The 'Depends on:' line lists symbols that need to be defined for\n"
+"   this symbol to be visible and selectable in the menu.\n"
+"o  The 'Location:' lines tell, where in the menu structure this symbol\n"
+"   is located.  A location followed by a [ = y] indicates that this is\n"
+"   a selectable menu item, and the current value is displayed inside\n"
+"   brackets.\n"
+"o  The 'Selects:' line tells, what symbol will be automatically selected\n"
+"   if this symbol is selected (y or m).\n"
+"o  The 'Selected by' line tells what symbol has selected this symbol.\n"
 "\n"
 "Only relevant lines are shown.\n"
 "\n\n"
 "Search examples:\n"
-"Examples: USB  => find all symbols containing USB\n"
-"          ^USB => find all symbols starting with USB\n"
-"          USB$ => find all symbols ending with USB\n"
+"USB  => find all symbols containing USB\n"
+"^USB => find all symbols starting with USB\n"
+"USB$ => find all symbols ending with USB\n"
 "\n");
 
 struct mitem {
@@ -319,19 +312,19 @@ struct function_keys function_keys[] = {
        },
        {
                .key_str = "F2",
-               .func = "Sym Info",
+               .func = "SymInfo",
                .key = F_SYMBOL,
                .handler = handle_f2,
        },
        {
                .key_str = "F3",
-               .func = "Insts",
+               .func = "Help 2",
                .key = F_INSTS,
                .handler = handle_f3,
        },
        {
                .key_str = "F4",
-               .func = "Config",
+               .func = "ShowAll",
                .key = F_CONF,
                .handler = handle_f4,
        },
@@ -355,7 +348,7 @@ struct function_keys function_keys[] = {
        },
        {
                .key_str = "F8",
-               .func = "Sym Search",
+               .func = "SymSearch",
                .key = F_SEARCH,
                .handler = handle_f8,
        },
@@ -392,7 +385,7 @@ static void print_function_line(void)
 static void handle_f1(int *key, struct menu *current_item)
 {
        show_scroll_win(main_window,
-                       _("README"), _(nconf_readme));
+                       _("Global help"), _(nconf_global_help));
        return;
 }
 
@@ -407,7 +400,7 @@ static void handle_f2(int *key, struct menu *current_item)
 static void handle_f3(int *key, struct menu *current_item)
 {
        show_scroll_win(main_window,
-                       _("Instructions"),
+                       _("Short help"),
                        _(current_instructions));
        return;
 }
@@ -696,13 +689,18 @@ static void search_conf(void)
 {
        struct symbol **sym_arr;
        struct gstr res;
+       struct gstr title;
        char *dialog_input;
        int dres;
+
+       title = str_new();
+       str_printf( &title, _("Enter %s (sub)string to search for "
+                             "(with or without \"%s\")"), CONFIG_, CONFIG_);
+
 again:
        dres = dialog_inputbox(main_window,
                        _("Search Configuration Parameter"),
-                       _("Enter " CONFIG_ " (sub)string to search for "
-                               "(with or without \"" CONFIG_ "\")"),
+                       str_get(&title),
                        "", &dialog_input_result, &dialog_input_result_len);
        switch (dres) {
        case 0:
@@ -712,6 +710,7 @@ again:
                                _("Search Configuration"), search_help);
                goto again;
        default:
+               str_free(&title);
                return;
        }
 
@@ -726,6 +725,7 @@ again:
        show_scroll_win(main_window,
                        _("Search Results"), str_get(&res));
        str_free(&res);
+       str_free(&title);
 }
 
 
index 379003c..9f8c44e 100644 (file)
@@ -48,7 +48,7 @@ static void set_normal_colors(void)
        init_pair(INPUT_FIELD, -1, -1);
 
        init_pair(FUNCTION_HIGHLIGHT, -1, -1);
-       init_pair(FUNCTION_TEXT, COLOR_BLUE, -1);
+       init_pair(FUNCTION_TEXT, COLOR_YELLOW, -1);
 }
 
 /* available attributes:
index df274fe..1500c38 100644 (file)
@@ -6,6 +6,7 @@
 #include <qglobal.h>
 
 #if QT_VERSION < 0x040000
+#include <stddef.h>
 #include <qmainwindow.h>
 #include <qvbox.h>
 #include <qvaluelist.h>
index 22a3c40..ecc5aa5 100644 (file)
@@ -656,11 +656,11 @@ bool sym_set_string_value(struct symbol *sym, const char *newval)
        size = strlen(newval) + 1;
        if (sym->type == S_HEX && (newval[0] != '0' || (newval[1] != 'x' && newval[1] != 'X'))) {
                size += 2;
-               sym->def[S_DEF_USER].val = val = malloc(size);
+               sym->def[S_DEF_USER].val = val = xmalloc(size);
                *val++ = '0';
                *val++ = 'x';
        } else if (!oldval || strcmp(oldval, newval))
-               sym->def[S_DEF_USER].val = val = malloc(size);
+               sym->def[S_DEF_USER].val = val = xmalloc(size);
        else
                return true;
 
@@ -812,7 +812,7 @@ struct symbol *sym_lookup(const char *name, int flags)
                hash = 0;
        }
 
-       symbol = malloc(sizeof(*symbol));
+       symbol = xmalloc(sizeof(*symbol));
        memset(symbol, 0, sizeof(*symbol));
        symbol->name = new_name;
        symbol->type = S_UNKNOWN;
@@ -863,7 +863,7 @@ const char *sym_expand_string_value(const char *in)
        size_t reslen;
 
        reslen = strlen(in) + 1;
-       res = malloc(reslen);
+       res = xmalloc(reslen);
        res[0] = '\0';
 
        while ((src = strchr(in, '$'))) {
@@ -921,7 +921,7 @@ const char *sym_escape_string_value(const char *in)
                p++;
        }
 
-       res = malloc(reslen);
+       res = xmalloc(reslen);
        res[0] = '\0';
 
        strcat(res, "\"");
@@ -1228,7 +1228,7 @@ struct property *prop_alloc(enum prop_type type, struct symbol *sym)
        struct property *prop;
        struct property **propp;
 
-       prop = malloc(sizeof(*prop));
+       prop = xmalloc(sizeof(*prop));
        memset(prop, 0, sizeof(*prop));
        prop->type = type;
        prop->sym = sym;
index d0b8b23..6e7fbf1 100644 (file)
@@ -23,7 +23,7 @@ struct file *file_lookup(const char *name)
                }
        }
 
-       file = malloc(sizeof(*file));
+       file = xmalloc(sizeof(*file));
        memset(file, 0, sizeof(*file));
        file->name = file_name;
        file->next = file_list;
@@ -81,7 +81,7 @@ int file_write_dep(const char *name)
 struct gstr str_new(void)
 {
        struct gstr gs;
-       gs.s = malloc(sizeof(char) * 64);
+       gs.s = xmalloc(sizeof(char) * 64);
        gs.len = 64;
        gs.max_width = 0;
        strcpy(gs.s, "\0");
@@ -138,3 +138,22 @@ const char *str_get(struct gstr *gs)
        return gs->s;
 }
 
+void *xmalloc(size_t size)
+{
+       void *p = malloc(size);
+       if (p)
+               return p;
+       fprintf(stderr, "Out of memory.\n");
+       exit(1);
+}
+
+void *xcalloc(size_t nmemb, size_t size)
+{
+       void *p = calloc(nmemb, size);
+       if (p)
+               return p;
+       fprintf(stderr, "Out of memory.\n");
+       exit(1);
+}
+
+
index 00f9d3a..6555a47 100644 (file)
@@ -40,7 +40,7 @@ static void zconf_endfile(void);
 
 static void new_string(void)
 {
-       text = malloc(START_STRSIZE);
+       text = xmalloc(START_STRSIZE);
        text_asize = START_STRSIZE;
        text_size = 0;
        *text = 0;
@@ -62,7 +62,7 @@ static void append_string(const char *str, int size)
 
 static void alloc_string(const char *str, int size)
 {
-       text = malloc(size + 1);
+       text = xmalloc(size + 1);
        memcpy(text, str, size);
        text[size] = 0;
 }
@@ -288,7 +288,7 @@ void zconf_initscan(const char *name)
                exit(1);
        }
 
-       current_buf = malloc(sizeof(*current_buf));
+       current_buf = xmalloc(sizeof(*current_buf));
        memset(current_buf, 0, sizeof(*current_buf));
 
        current_file = file_lookup(name);
@@ -299,7 +299,7 @@ void zconf_nextfile(const char *name)
 {
        struct file *iter;
        struct file *file = file_lookup(name);
-       struct buffer *buf = malloc(sizeof(*buf));
+       struct buffer *buf = xmalloc(sizeof(*buf));
        memset(buf, 0, sizeof(*buf));
 
        current_buf->state = YY_CURRENT_BUFFER;
index c32b1a4..a0521aa 100644 (file)
@@ -802,7 +802,7 @@ static void zconf_endfile(void);
 
 static void new_string(void)
 {
-       text = malloc(START_STRSIZE);
+       text = xmalloc(START_STRSIZE);
        text_asize = START_STRSIZE;
        text_size = 0;
        *text = 0;
@@ -824,7 +824,7 @@ static void append_string(const char *str, int size)
 
 static void alloc_string(const char *str, int size)
 {
-       text = malloc(size + 1);
+       text = xmalloc(size + 1);
        memcpy(text, str, size);
        text[size] = 0;
 }
@@ -2343,7 +2343,7 @@ void zconf_initscan(const char *name)
                exit(1);
        }
 
-       current_buf = malloc(sizeof(*current_buf));
+       current_buf = xmalloc(sizeof(*current_buf));
        memset(current_buf, 0, sizeof(*current_buf));
 
        current_file = file_lookup(name);
@@ -2354,7 +2354,7 @@ void zconf_nextfile(const char *name)
 {
        struct file *iter;
        struct file *file = file_lookup(name);
-       struct buffer *buf = malloc(sizeof(*buf));
+       struct buffer *buf = xmalloc(sizeof(*buf));
        memset(buf, 0, sizeof(*buf));
 
        current_buf->state = YY_CURRENT_BUFFER;
index b3d907e..3d569d6 100644 (file)
@@ -132,7 +132,14 @@ if [ "$1" = "clean" ]; then
 fi
 
 # We need access to CONFIG_ symbols
-. ./.config
+case "${KCONFIG_CONFIG}" in
+*/*)
+       . "${KCONFIG_CONFIG}"
+       ;;
+*)
+       # Force using a file from the current directory
+       . "./${KCONFIG_CONFIG}"
+esac
 
 #link vmlinux.o
 info LD vmlinux.o
index e9b7abe..33bae0d 100644 (file)
@@ -1,4 +1,5 @@
 elfconfig.h
 mk_elfconfig
 modpost
+devicetable-offsets.h
 
index ff954f8..9415b56 100644 (file)
@@ -3,9 +3,44 @@ always         := $(hostprogs-y) empty.o
 
 modpost-objs   := modpost.o file2alias.o sumversion.o
 
+devicetable-offsets-file := devicetable-offsets.h
+
+define sed-y
+       "/^->/{s:->#\(.*\):/* \1 */:; \
+       s:^->\([^ ]*\) [\$$#]*\([-0-9]*\) \(.*\):#define \1 \2 /* \3 */:; \
+       s:^->\([^ ]*\) [\$$#]*\([^ ]*\) \(.*\):#define \1 \2 /* \3 */:; \
+       s:->::; p;}"
+endef
+
+quiet_cmd_offsets = GEN     $@
+define cmd_offsets
+       (set -e; \
+        echo "#ifndef __DEVICEVTABLE_OFFSETS_H__"; \
+        echo "#define __DEVICEVTABLE_OFFSETS_H__"; \
+        echo "/*"; \
+        echo " * DO NOT MODIFY."; \
+        echo " *"; \
+        echo " * This file was generated by Kbuild"; \
+        echo " *"; \
+        echo " */"; \
+        echo ""; \
+        sed -ne $(sed-y) $<; \
+        echo ""; \
+        echo "#endif" ) > $@
+endef
+
+# We use internal kbuild rules to avoid the "is up to date" message from make
+scripts/mod/devicetable-offsets.s: scripts/mod/devicetable-offsets.c FORCE
+       $(Q)mkdir -p $(dir $@)
+       $(call if_changed_dep,cc_s_c)
+
+$(obj)/$(devicetable-offsets-file): scripts/mod/devicetable-offsets.s
+       $(call cmd,offsets)
+
 # dependencies on generated files need to be listed explicitly
 
 $(obj)/modpost.o $(obj)/file2alias.o $(obj)/sumversion.o: $(obj)/elfconfig.h
+$(obj)/file2alias.o: $(obj)/$(devicetable-offsets-file)
 
 quiet_cmd_elfconfig = MKELF   $@
       cmd_elfconfig = $(obj)/mk_elfconfig < $< > $@
diff --git a/scripts/mod/devicetable-offsets.c b/scripts/mod/devicetable-offsets.c
new file mode 100644 (file)
index 0000000..b45260b
--- /dev/null
@@ -0,0 +1,178 @@
+#include <linux/kbuild.h>
+#include <linux/mod_devicetable.h>
+
+#define DEVID(devid) DEFINE(SIZE_##devid, sizeof(struct devid))
+#define DEVID_FIELD(devid, field) \
+       DEFINE(OFF_##devid##_##field, offsetof(struct devid, field))
+
+int main(void)
+{
+       DEVID(usb_device_id);
+       DEVID_FIELD(usb_device_id, match_flags);
+       DEVID_FIELD(usb_device_id, idVendor);
+       DEVID_FIELD(usb_device_id, idProduct);
+       DEVID_FIELD(usb_device_id, bcdDevice_lo);
+       DEVID_FIELD(usb_device_id, bcdDevice_hi);
+       DEVID_FIELD(usb_device_id, bDeviceClass);
+       DEVID_FIELD(usb_device_id, bDeviceSubClass);
+       DEVID_FIELD(usb_device_id, bDeviceProtocol);
+       DEVID_FIELD(usb_device_id, bInterfaceClass);
+       DEVID_FIELD(usb_device_id, bInterfaceSubClass);
+       DEVID_FIELD(usb_device_id, bInterfaceProtocol);
+       DEVID_FIELD(usb_device_id, bInterfaceNumber);
+
+       DEVID(hid_device_id);
+       DEVID_FIELD(hid_device_id, bus);
+       DEVID_FIELD(hid_device_id, group);
+       DEVID_FIELD(hid_device_id, vendor);
+       DEVID_FIELD(hid_device_id, product);
+
+       DEVID(ieee1394_device_id);
+       DEVID_FIELD(ieee1394_device_id, match_flags);
+       DEVID_FIELD(ieee1394_device_id, vendor_id);
+       DEVID_FIELD(ieee1394_device_id, model_id);
+       DEVID_FIELD(ieee1394_device_id, specifier_id);
+       DEVID_FIELD(ieee1394_device_id, version);
+
+       DEVID(pci_device_id);
+       DEVID_FIELD(pci_device_id, vendor);
+       DEVID_FIELD(pci_device_id, device);
+       DEVID_FIELD(pci_device_id, subvendor);
+       DEVID_FIELD(pci_device_id, subdevice);
+       DEVID_FIELD(pci_device_id, class);
+       DEVID_FIELD(pci_device_id, class_mask);
+
+       DEVID(ccw_device_id);
+       DEVID_FIELD(ccw_device_id, match_flags);
+       DEVID_FIELD(ccw_device_id, cu_type);
+       DEVID_FIELD(ccw_device_id, cu_model);
+       DEVID_FIELD(ccw_device_id, dev_type);
+       DEVID_FIELD(ccw_device_id, dev_model);
+
+       DEVID(ap_device_id);
+       DEVID_FIELD(ap_device_id, dev_type);
+
+       DEVID(css_device_id);
+       DEVID_FIELD(css_device_id, type);
+
+       DEVID(serio_device_id);
+       DEVID_FIELD(serio_device_id, type);
+       DEVID_FIELD(serio_device_id, proto);
+       DEVID_FIELD(serio_device_id, id);
+       DEVID_FIELD(serio_device_id, extra);
+
+       DEVID(acpi_device_id);
+       DEVID_FIELD(acpi_device_id, id);
+
+       DEVID(pnp_device_id);
+       DEVID_FIELD(pnp_device_id, id);
+
+       DEVID(pnp_card_device_id);
+       DEVID_FIELD(pnp_card_device_id, devs);
+
+       DEVID(pcmcia_device_id);
+       DEVID_FIELD(pcmcia_device_id, match_flags);
+       DEVID_FIELD(pcmcia_device_id, manf_id);
+       DEVID_FIELD(pcmcia_device_id, card_id);
+       DEVID_FIELD(pcmcia_device_id, func_id);
+       DEVID_FIELD(pcmcia_device_id, function);
+       DEVID_FIELD(pcmcia_device_id, device_no);
+       DEVID_FIELD(pcmcia_device_id, prod_id_hash);
+
+       DEVID(of_device_id);
+       DEVID_FIELD(of_device_id, name);
+       DEVID_FIELD(of_device_id, type);
+       DEVID_FIELD(of_device_id, compatible);
+
+       DEVID(vio_device_id);
+       DEVID_FIELD(vio_device_id, type);
+       DEVID_FIELD(vio_device_id, compat);
+
+       DEVID(input_device_id);
+       DEVID_FIELD(input_device_id, flags);
+       DEVID_FIELD(input_device_id, bustype);
+       DEVID_FIELD(input_device_id, vendor);
+       DEVID_FIELD(input_device_id, product);
+       DEVID_FIELD(input_device_id, version);
+       DEVID_FIELD(input_device_id, evbit);
+       DEVID_FIELD(input_device_id, keybit);
+       DEVID_FIELD(input_device_id, relbit);
+       DEVID_FIELD(input_device_id, absbit);
+       DEVID_FIELD(input_device_id, mscbit);
+       DEVID_FIELD(input_device_id, ledbit);
+       DEVID_FIELD(input_device_id, sndbit);
+       DEVID_FIELD(input_device_id, ffbit);
+       DEVID_FIELD(input_device_id, swbit);
+
+       DEVID(eisa_device_id);
+       DEVID_FIELD(eisa_device_id, sig);
+
+       DEVID(parisc_device_id);
+       DEVID_FIELD(parisc_device_id, hw_type);
+       DEVID_FIELD(parisc_device_id, hversion);
+       DEVID_FIELD(parisc_device_id, hversion_rev);
+       DEVID_FIELD(parisc_device_id, sversion);
+
+       DEVID(sdio_device_id);
+       DEVID_FIELD(sdio_device_id, class);
+       DEVID_FIELD(sdio_device_id, vendor);
+       DEVID_FIELD(sdio_device_id, device);
+
+       DEVID(ssb_device_id);
+       DEVID_FIELD(ssb_device_id, vendor);
+       DEVID_FIELD(ssb_device_id, coreid);
+       DEVID_FIELD(ssb_device_id, revision);
+
+       DEVID(bcma_device_id);
+       DEVID_FIELD(bcma_device_id, manuf);
+       DEVID_FIELD(bcma_device_id, id);
+       DEVID_FIELD(bcma_device_id, rev);
+       DEVID_FIELD(bcma_device_id, class);
+
+       DEVID(virtio_device_id);
+       DEVID_FIELD(virtio_device_id, device);
+       DEVID_FIELD(virtio_device_id, vendor);
+
+       DEVID(hv_vmbus_device_id);
+       DEVID_FIELD(hv_vmbus_device_id, guid);
+
+       DEVID(i2c_device_id);
+       DEVID_FIELD(i2c_device_id, name);
+
+       DEVID(spi_device_id);
+       DEVID_FIELD(spi_device_id, name);
+
+       DEVID(dmi_system_id);
+       DEVID_FIELD(dmi_system_id, matches);
+
+       DEVID(platform_device_id);
+       DEVID_FIELD(platform_device_id, name);
+
+       DEVID(mdio_device_id);
+       DEVID_FIELD(mdio_device_id, phy_id);
+       DEVID_FIELD(mdio_device_id, phy_id_mask);
+
+       DEVID(zorro_device_id);
+       DEVID_FIELD(zorro_device_id, id);
+
+       DEVID(isapnp_device_id);
+       DEVID_FIELD(isapnp_device_id, vendor);
+       DEVID_FIELD(isapnp_device_id, function);
+
+       DEVID(ipack_device_id);
+       DEVID_FIELD(ipack_device_id, format);
+       DEVID_FIELD(ipack_device_id, vendor);
+       DEVID_FIELD(ipack_device_id, device);
+
+       DEVID(amba_id);
+       DEVID_FIELD(amba_id, id);
+       DEVID_FIELD(amba_id, mask);
+
+       DEVID(x86_cpu_id);
+       DEVID_FIELD(x86_cpu_id, feature);
+       DEVID_FIELD(x86_cpu_id, family);
+       DEVID_FIELD(x86_cpu_id, model);
+       DEVID_FIELD(x86_cpu_id, vendor);
+
+       return 0;
+}
index df4fc23..771ac17 100644 (file)
@@ -11,6 +11,7 @@
  */
 
 #include "modpost.h"
+#include "devicetable-offsets.h"
 
 /* We use the ELF typedefs for kernel_ulong_t but bite the bullet and
  * use either stdint.h or inttypes.h for the rest. */
@@ -84,13 +85,25 @@ extern struct devtable *__start___devtable[], *__stop___devtable[];
 # define __used                        __attribute__((__used__))
 #endif
 
+/* Define a variable f that holds the value of field f of struct devid
+ * based at address m.
+ */
+#define DEF_FIELD(m, devid, f) \
+       typeof(((struct devid *)0)->f) f = TO_NATIVE(*(typeof(f) *)((m) + OFF_##devid##_##f))
+/* Define a variable f that holds the address of field f of struct devid
+ * based at address m.  Due to the way typeof works, for a field of type
+ * T[N] the variable has type T(*)[N], _not_ T*.
+ */
+#define DEF_FIELD_ADDR(m, devid, f) \
+       typeof(((struct devid *)0)->f) *f = ((m) + OFF_##devid##_##f)
+
 /* Add a table entry.  We test function type matches while we're here. */
 #define ADD_TO_DEVTABLE(device_id, type, function) \
        static struct devtable __cat(devtable,__LINE__) = {     \
                device_id + 0*sizeof((function)((const char *)NULL,     \
-                                               (type *)NULL,           \
+                                               (void *)NULL,           \
                                                (char *)NULL)),         \
-               sizeof(type), (function) };                             \
+               SIZE_##type, (function) };                              \
        static struct devtable *SECTION(__devtable) __used \
                __cat(devtable_ptr,__LINE__) = &__cat(devtable,__LINE__)
 
@@ -116,7 +129,6 @@ static inline void add_wildcard(char *str)
                strcat(str + len, "*");
 }
 
-unsigned int cross_build = 0;
 /**
  * Check that sizeof(device_id type) are consistent with size of section
  * in .o file. If in-consistent then userspace and kernel does not agree
@@ -131,8 +143,6 @@ static void device_id_check(const char *modname, const char *device_id,
        int i;
 
        if (size % id_size || size < id_size) {
-               if (cross_build != 0)
-                       return;
                fatal("%s: sizeof(struct %s_device_id)=%lu is not a modulo "
                      "of the size of section __mod_%s_device_table=%lu.\n"
                      "Fix definition of struct %s_device_id "
@@ -157,17 +167,29 @@ static void device_id_check(const char *modname, const char *device_id,
 
 /* USB is special because the bcdDevice can be matched against a numeric range */
 /* Looks like "usb:vNpNdNdcNdscNdpNicNiscNipNinN" */
-static void do_usb_entry(struct usb_device_id *id,
+static void do_usb_entry(void *symval,
                         unsigned int bcdDevice_initial, int bcdDevice_initial_digits,
                         unsigned char range_lo, unsigned char range_hi,
                         unsigned char max, struct module *mod)
 {
        char alias[500];
+       DEF_FIELD(symval, usb_device_id, match_flags);
+       DEF_FIELD(symval, usb_device_id, idVendor);
+       DEF_FIELD(symval, usb_device_id, idProduct);
+       DEF_FIELD(symval, usb_device_id, bcdDevice_lo);
+       DEF_FIELD(symval, usb_device_id, bDeviceClass);
+       DEF_FIELD(symval, usb_device_id, bDeviceSubClass);
+       DEF_FIELD(symval, usb_device_id, bDeviceProtocol);
+       DEF_FIELD(symval, usb_device_id, bInterfaceClass);
+       DEF_FIELD(symval, usb_device_id, bInterfaceSubClass);
+       DEF_FIELD(symval, usb_device_id, bInterfaceProtocol);
+       DEF_FIELD(symval, usb_device_id, bInterfaceNumber);
+
        strcpy(alias, "usb:");
-       ADD(alias, "v", id->match_flags&USB_DEVICE_ID_MATCH_VENDOR,
-           id->idVendor);
-       ADD(alias, "p", id->match_flags&USB_DEVICE_ID_MATCH_PRODUCT,
-           id->idProduct);
+       ADD(alias, "v", match_flags&USB_DEVICE_ID_MATCH_VENDOR,
+           idVendor);
+       ADD(alias, "p", match_flags&USB_DEVICE_ID_MATCH_PRODUCT,
+           idProduct);
 
        strcat(alias, "d");
        if (bcdDevice_initial_digits)
@@ -190,29 +212,23 @@ static void do_usb_entry(struct usb_device_id *id,
                                range_lo);
                }
        }
-       if (bcdDevice_initial_digits < (sizeof(id->bcdDevice_lo) * 2 - 1))
+       if (bcdDevice_initial_digits < (sizeof(bcdDevice_lo) * 2 - 1))
                strcat(alias, "*");
 
-       ADD(alias, "dc", id->match_flags&USB_DEVICE_ID_MATCH_DEV_CLASS,
-           id->bDeviceClass);
-       ADD(alias, "dsc",
-           id->match_flags&USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
-           id->bDeviceSubClass);
-       ADD(alias, "dp",
-           id->match_flags&USB_DEVICE_ID_MATCH_DEV_PROTOCOL,
-           id->bDeviceProtocol);
-       ADD(alias, "ic",
-           id->match_flags&USB_DEVICE_ID_MATCH_INT_CLASS,
-           id->bInterfaceClass);
-       ADD(alias, "isc",
-           id->match_flags&USB_DEVICE_ID_MATCH_INT_SUBCLASS,
-           id->bInterfaceSubClass);
-       ADD(alias, "ip",
-           id->match_flags&USB_DEVICE_ID_MATCH_INT_PROTOCOL,
-           id->bInterfaceProtocol);
-       ADD(alias, "in",
-           id->match_flags&USB_DEVICE_ID_MATCH_INT_NUMBER,
-           id->bInterfaceNumber);
+       ADD(alias, "dc", match_flags&USB_DEVICE_ID_MATCH_DEV_CLASS,
+           bDeviceClass);
+       ADD(alias, "dsc", match_flags&USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
+           bDeviceSubClass);
+       ADD(alias, "dp", match_flags&USB_DEVICE_ID_MATCH_DEV_PROTOCOL,
+           bDeviceProtocol);
+       ADD(alias, "ic", match_flags&USB_DEVICE_ID_MATCH_INT_CLASS,
+           bInterfaceClass);
+       ADD(alias, "isc", match_flags&USB_DEVICE_ID_MATCH_INT_SUBCLASS,
+           bInterfaceSubClass);
+       ADD(alias, "ip", match_flags&USB_DEVICE_ID_MATCH_INT_PROTOCOL,
+           bInterfaceProtocol);
+       ADD(alias, "in", match_flags&USB_DEVICE_ID_MATCH_INT_NUMBER,
+           bInterfaceNumber);
 
        add_wildcard(alias);
        buf_printf(&mod->dev_table_buf,
@@ -258,24 +274,28 @@ static unsigned int incbcd(unsigned int *bcd,
        return init;
 }
 
-static void do_usb_entry_multi(struct usb_device_id *id, struct module *mod)
+static void do_usb_entry_multi(void *symval, struct module *mod)
 {
        unsigned int devlo, devhi;
        unsigned char chi, clo, max;
        int ndigits;
 
-       id->match_flags = TO_NATIVE(id->match_flags);
-       id->idVendor = TO_NATIVE(id->idVendor);
-       id->idProduct = TO_NATIVE(id->idProduct);
+       DEF_FIELD(symval, usb_device_id, match_flags);
+       DEF_FIELD(symval, usb_device_id, idVendor);
+       DEF_FIELD(symval, usb_device_id, idProduct);
+       DEF_FIELD(symval, usb_device_id, bcdDevice_lo);
+       DEF_FIELD(symval, usb_device_id, bcdDevice_hi);
+       DEF_FIELD(symval, usb_device_id, bDeviceClass);
+       DEF_FIELD(symval, usb_device_id, bInterfaceClass);
 
-       devlo = id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO ?
-               TO_NATIVE(id->bcdDevice_lo) : 0x0U;
-       devhi = id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI ?
-               TO_NATIVE(id->bcdDevice_hi) : ~0x0U;
+       devlo = match_flags & USB_DEVICE_ID_MATCH_DEV_LO ?
+               bcdDevice_lo : 0x0U;
+       devhi = match_flags & USB_DEVICE_ID_MATCH_DEV_HI ?
+               bcdDevice_hi : ~0x0U;
 
        /* Figure out if this entry is in bcd or hex format */
        max = 0x9; /* Default to decimal format */
-       for (ndigits = 0 ; ndigits < sizeof(id->bcdDevice_lo) * 2 ; ndigits++) {
+       for (ndigits = 0 ; ndigits < sizeof(bcdDevice_lo) * 2 ; ndigits++) {
                clo = (devlo >> (ndigits << 2)) & 0xf;
                chi = ((devhi > 0x9999 ? 0x9999 : devhi) >> (ndigits << 2)) & 0xf;
                if (clo > max || chi > max) {
@@ -288,11 +308,11 @@ static void do_usb_entry_multi(struct usb_device_id *id, struct module *mod)
         * Some modules (visor) have empty slots as placeholder for
         * run-time specification that results in catch-all alias
         */
-       if (!(id->idVendor | id->idProduct | id->bDeviceClass | id->bInterfaceClass))
+       if (!(idVendor | idProduct | bDeviceClass | bInterfaceClass))
                return;
 
        /* Convert numeric bcdDevice range into fnmatch-able pattern(s) */
-       for (ndigits = sizeof(id->bcdDevice_lo) * 2 - 1; devlo <= devhi; ndigits--) {
+       for (ndigits = sizeof(bcdDevice_lo) * 2 - 1; devlo <= devhi; ndigits--) {
                clo = devlo & 0xf;
                chi = devhi & 0xf;
                if (chi > max)  /* If we are in bcd mode, truncate if necessary */
@@ -301,20 +321,20 @@ static void do_usb_entry_multi(struct usb_device_id *id, struct module *mod)
                devhi >>= 4;
 
                if (devlo == devhi || !ndigits) {
-                       do_usb_entry(id, devlo, ndigits, clo, chi, max, mod);
+                       do_usb_entry(symval, devlo, ndigits, clo, chi, max, mod);
                        break;
                }
 
                if (clo > 0x0)
-                       do_usb_entry(id,
+                       do_usb_entry(symval,
                                     incbcd(&devlo, 1, max,
-                                           sizeof(id->bcdDevice_lo) * 2),
+                                           sizeof(bcdDevice_lo) * 2),
                                     ndigits, clo, max, max, mod);
 
                if (chi < max)
-                       do_usb_entry(id,
+                       do_usb_entry(symval,
                                     incbcd(&devhi, -1, max,
-                                           sizeof(id->bcdDevice_lo) * 2),
+                                           sizeof(bcdDevice_lo) * 2),
                                     ndigits, 0x0, chi, max, mod);
        }
 }
@@ -323,7 +343,7 @@ static void do_usb_table(void *symval, unsigned long size,
                         struct module *mod)
 {
        unsigned int i;
-       const unsigned long id_size = sizeof(struct usb_device_id);
+       const unsigned long id_size = SIZE_usb_device_id;
 
        device_id_check(mod->name, "usb", size, id_size, symval);
 
@@ -336,81 +356,81 @@ static void do_usb_table(void *symval, unsigned long size,
 
 /* Looks like: hid:bNvNpN */
 static int do_hid_entry(const char *filename,
-                            struct hid_device_id *id, char *alias)
+                            void *symval, char *alias)
 {
-       id->bus = TO_NATIVE(id->bus);
-       id->group = TO_NATIVE(id->group);
-       id->vendor = TO_NATIVE(id->vendor);
-       id->product = TO_NATIVE(id->product);
+       DEF_FIELD(symval, hid_device_id, bus);
+       DEF_FIELD(symval, hid_device_id, group);
+       DEF_FIELD(symval, hid_device_id, vendor);
+       DEF_FIELD(symval, hid_device_id, product);
 
        sprintf(alias, "hid:");
-       ADD(alias, "b", id->bus != HID_BUS_ANY, id->bus);
-       ADD(alias, "g", id->group != HID_GROUP_ANY, id->group);
-       ADD(alias, "v", id->vendor != HID_ANY_ID, id->vendor);
-       ADD(alias, "p", id->product != HID_ANY_ID, id->product);
+       ADD(alias, "b", bus != HID_BUS_ANY, bus);
+       ADD(alias, "g", group != HID_GROUP_ANY, group);
+       ADD(alias, "v", vendor != HID_ANY_ID, vendor);
+       ADD(alias, "p", product != HID_ANY_ID, product);
 
        return 1;
 }
-ADD_TO_DEVTABLE("hid", struct hid_device_id, do_hid_entry);
+ADD_TO_DEVTABLE("hid", hid_device_id, do_hid_entry);
 
 /* Looks like: ieee1394:venNmoNspNverN */
 static int do_ieee1394_entry(const char *filename,
-                            struct ieee1394_device_id *id, char *alias)
+                            void *symval, char *alias)
 {
-       id->match_flags = TO_NATIVE(id->match_flags);
-       id->vendor_id = TO_NATIVE(id->vendor_id);
-       id->model_id = TO_NATIVE(id->model_id);
-       id->specifier_id = TO_NATIVE(id->specifier_id);
-       id->version = TO_NATIVE(id->version);
+       DEF_FIELD(symval, ieee1394_device_id, match_flags);
+       DEF_FIELD(symval, ieee1394_device_id, vendor_id);
+       DEF_FIELD(symval, ieee1394_device_id, model_id);
+       DEF_FIELD(symval, ieee1394_device_id, specifier_id);
+       DEF_FIELD(symval, ieee1394_device_id, version);
 
        strcpy(alias, "ieee1394:");
-       ADD(alias, "ven", id->match_flags & IEEE1394_MATCH_VENDOR_ID,
-           id->vendor_id);
-       ADD(alias, "mo", id->match_flags & IEEE1394_MATCH_MODEL_ID,
-           id->model_id);
-       ADD(alias, "sp", id->match_flags & IEEE1394_MATCH_SPECIFIER_ID,
-           id->specifier_id);
-       ADD(alias, "ver", id->match_flags & IEEE1394_MATCH_VERSION,
-           id->version);
+       ADD(alias, "ven", match_flags & IEEE1394_MATCH_VENDOR_ID,
+           vendor_id);
+       ADD(alias, "mo", match_flags & IEEE1394_MATCH_MODEL_ID,
+           model_id);
+       ADD(alias, "sp", match_flags & IEEE1394_MATCH_SPECIFIER_ID,
+           specifier_id);
+       ADD(alias, "ver", match_flags & IEEE1394_MATCH_VERSION,
+           version);
 
        add_wildcard(alias);
        return 1;
 }
-ADD_TO_DEVTABLE("ieee1394", struct ieee1394_device_id, do_ieee1394_entry);
+ADD_TO_DEVTABLE("ieee1394", ieee1394_device_id, do_ieee1394_entry);
 
 /* Looks like: pci:vNdNsvNsdNbcNscNiN. */
 static int do_pci_entry(const char *filename,
-                       struct pci_device_id *id, char *alias)
+                       void *symval, char *alias)
 {
        /* Class field can be divided into these three. */
        unsigned char baseclass, subclass, interface,
                baseclass_mask, subclass_mask, interface_mask;
 
-       id->vendor = TO_NATIVE(id->vendor);
-       id->device = TO_NATIVE(id->device);
-       id->subvendor = TO_NATIVE(id->subvendor);
-       id->subdevice = TO_NATIVE(id->subdevice);
-       id->class = TO_NATIVE(id->class);
-       id->class_mask = TO_NATIVE(id->class_mask);
+       DEF_FIELD(symval, pci_device_id, vendor);
+       DEF_FIELD(symval, pci_device_id, device);
+       DEF_FIELD(symval, pci_device_id, subvendor);
+       DEF_FIELD(symval, pci_device_id, subdevice);
+       DEF_FIELD(symval, pci_device_id, class);
+       DEF_FIELD(symval, pci_device_id, class_mask);
 
        strcpy(alias, "pci:");
-       ADD(alias, "v", id->vendor != PCI_ANY_ID, id->vendor);
-       ADD(alias, "d", id->device != PCI_ANY_ID, id->device);
-       ADD(alias, "sv", id->subvendor != PCI_ANY_ID, id->subvendor);
-       ADD(alias, "sd", id->subdevice != PCI_ANY_ID, id->subdevice);
-
-       baseclass = (id->class) >> 16;
-       baseclass_mask = (id->class_mask) >> 16;
-       subclass = (id->class) >> 8;
-       subclass_mask = (id->class_mask) >> 8;
-       interface = id->class;
-       interface_mask = id->class_mask;
+       ADD(alias, "v", vendor != PCI_ANY_ID, vendor);
+       ADD(alias, "d", device != PCI_ANY_ID, device);
+       ADD(alias, "sv", subvendor != PCI_ANY_ID, subvendor);
+       ADD(alias, "sd", subdevice != PCI_ANY_ID, subdevice);
+
+       baseclass = (class) >> 16;
+       baseclass_mask = (class_mask) >> 16;
+       subclass = (class) >> 8;
+       subclass_mask = (class_mask) >> 8;
+       interface = class;
+       interface_mask = class_mask;
 
        if ((baseclass_mask != 0 && baseclass_mask != 0xFF)
            || (subclass_mask != 0 && subclass_mask != 0xFF)
            || (interface_mask != 0 && interface_mask != 0xFF)) {
                warn("Can't handle masks in %s:%04X\n",
-                    filename, id->class_mask);
+                    filename, class_mask);
                return 0;
        }
 
@@ -420,101 +440,105 @@ static int do_pci_entry(const char *filename,
        add_wildcard(alias);
        return 1;
 }
-ADD_TO_DEVTABLE("pci", struct pci_device_id, do_pci_entry);
+ADD_TO_DEVTABLE("pci", pci_device_id, do_pci_entry);
 
 /* looks like: "ccw:tNmNdtNdmN" */
 static int do_ccw_entry(const char *filename,
-                       struct ccw_device_id *id, char *alias)
+                       void *symval, char *alias)
 {
-       id->match_flags = TO_NATIVE(id->match_flags);
-       id->cu_type = TO_NATIVE(id->cu_type);
-       id->cu_model = TO_NATIVE(id->cu_model);
-       id->dev_type = TO_NATIVE(id->dev_type);
-       id->dev_model = TO_NATIVE(id->dev_model);
+       DEF_FIELD(symval, ccw_device_id, match_flags);
+       DEF_FIELD(symval, ccw_device_id, cu_type);
+       DEF_FIELD(symval, ccw_device_id, cu_model);
+       DEF_FIELD(symval, ccw_device_id, dev_type);
+       DEF_FIELD(symval, ccw_device_id, dev_model);
 
        strcpy(alias, "ccw:");
-       ADD(alias, "t", id->match_flags&CCW_DEVICE_ID_MATCH_CU_TYPE,
-           id->cu_type);
-       ADD(alias, "m", id->match_flags&CCW_DEVICE_ID_MATCH_CU_MODEL,
-           id->cu_model);
-       ADD(alias, "dt", id->match_flags&CCW_DEVICE_ID_MATCH_DEVICE_TYPE,
-           id->dev_type);
-       ADD(alias, "dm", id->match_flags&CCW_DEVICE_ID_MATCH_DEVICE_MODEL,
-           id->dev_model);
+       ADD(alias, "t", match_flags&CCW_DEVICE_ID_MATCH_CU_TYPE,
+           cu_type);
+       ADD(alias, "m", match_flags&CCW_DEVICE_ID_MATCH_CU_MODEL,
+           cu_model);
+       ADD(alias, "dt", match_flags&CCW_DEVICE_ID_MATCH_DEVICE_TYPE,
+           dev_type);
+       ADD(alias, "dm", match_flags&CCW_DEVICE_ID_MATCH_DEVICE_MODEL,
+           dev_model);
        add_wildcard(alias);
        return 1;
 }
-ADD_TO_DEVTABLE("ccw", struct ccw_device_id, do_ccw_entry);
+ADD_TO_DEVTABLE("ccw", ccw_device_id, do_ccw_entry);
 
 /* looks like: "ap:tN" */
 static int do_ap_entry(const char *filename,
-                      struct ap_device_id *id, char *alias)
+                      void *symval, char *alias)
 {
-       sprintf(alias, "ap:t%02X*", id->dev_type);
+       DEF_FIELD(symval, ap_device_id, dev_type);
+
+       sprintf(alias, "ap:t%02X*", dev_type);
        return 1;
 }
-ADD_TO_DEVTABLE("ap", struct ap_device_id, do_ap_entry);
+ADD_TO_DEVTABLE("ap", ap_device_id, do_ap_entry);
 
 /* looks like: "css:tN" */
 static int do_css_entry(const char *filename,
-                       struct css_device_id *id, char *alias)
+                       void *symval, char *alias)
 {
-       sprintf(alias, "css:t%01X", id->type);
+       DEF_FIELD(symval, css_device_id, type);
+
+       sprintf(alias, "css:t%01X", type);
        return 1;
 }
-ADD_TO_DEVTABLE("css", struct css_device_id, do_css_entry);
+ADD_TO_DEVTABLE("css", css_device_id, do_css_entry);
 
 /* Looks like: "serio:tyNprNidNexN" */
 static int do_serio_entry(const char *filename,
-                         struct serio_device_id *id, char *alias)
+                         void *symval, char *alias)
 {
-       id->type = TO_NATIVE(id->type);
-       id->proto = TO_NATIVE(id->proto);
-       id->id = TO_NATIVE(id->id);
-       id->extra = TO_NATIVE(id->extra);
+       DEF_FIELD(symval, serio_device_id, type);
+       DEF_FIELD(symval, serio_device_id, proto);
+       DEF_FIELD(symval, serio_device_id, id);
+       DEF_FIELD(symval, serio_device_id, extra);
 
        strcpy(alias, "serio:");
-       ADD(alias, "ty", id->type != SERIO_ANY, id->type);
-       ADD(alias, "pr", id->proto != SERIO_ANY, id->proto);
-       ADD(alias, "id", id->id != SERIO_ANY, id->id);
-       ADD(alias, "ex", id->extra != SERIO_ANY, id->extra);
+       ADD(alias, "ty", type != SERIO_ANY, type);
+       ADD(alias, "pr", proto != SERIO_ANY, proto);
+       ADD(alias, "id", id != SERIO_ANY, id);
+       ADD(alias, "ex", extra != SERIO_ANY, extra);
 
        add_wildcard(alias);
        return 1;
 }
-ADD_TO_DEVTABLE("serio", struct serio_device_id, do_serio_entry);
+ADD_TO_DEVTABLE("serio", serio_device_id, do_serio_entry);
 
 /* looks like: "acpi:ACPI0003 or acpi:PNP0C0B" or "acpi:LNXVIDEO" */
 static int do_acpi_entry(const char *filename,
-                       struct acpi_device_id *id, char *alias)
+                       void *symval, char *alias)
 {
-       sprintf(alias, "acpi*:%s:*", id->id);
+       DEF_FIELD_ADDR(symval, acpi_device_id, id);
+       sprintf(alias, "acpi*:%s:*", *id);
        return 1;
 }
-ADD_TO_DEVTABLE("acpi", struct acpi_device_id, do_acpi_entry);
+ADD_TO_DEVTABLE("acpi", acpi_device_id, do_acpi_entry);
 
 /* looks like: "pnp:dD" */
 static void do_pnp_device_entry(void *symval, unsigned long size,
                                struct module *mod)
 {
-       const unsigned long id_size = sizeof(struct pnp_device_id);
+       const unsigned long id_size = SIZE_pnp_device_id;
        const unsigned int count = (size / id_size)-1;
-       const struct pnp_device_id *devs = symval;
        unsigned int i;
 
        device_id_check(mod->name, "pnp", size, id_size, symval);
 
        for (i = 0; i < count; i++) {
-               const char *id = (char *)devs[i].id;
-               char acpi_id[sizeof(devs[0].id)];
+               DEF_FIELD_ADDR(symval + i*id_size, pnp_device_id, id);
+               char acpi_id[sizeof(*id)];
                int j;
 
                buf_printf(&mod->dev_table_buf,
-                          "MODULE_ALIAS(\"pnp:d%s*\");\n", id);
+                          "MODULE_ALIAS(\"pnp:d%s*\");\n", *id);
 
                /* fix broken pnp bus lowercasing */
                for (j = 0; j < sizeof(acpi_id); j++)
-                       acpi_id[j] = toupper(id[j]);
+                       acpi_id[j] = toupper((*id)[j]);
                buf_printf(&mod->dev_table_buf,
                           "MODULE_ALIAS(\"acpi*:%s:*\");\n", acpi_id);
        }
@@ -524,19 +548,18 @@ static void do_pnp_device_entry(void *symval, unsigned long size,
 static void do_pnp_card_entries(void *symval, unsigned long size,
                                struct module *mod)
 {
-       const unsigned long id_size = sizeof(struct pnp_card_device_id);
+       const unsigned long id_size = SIZE_pnp_card_device_id;
        const unsigned int count = (size / id_size)-1;
-       const struct pnp_card_device_id *cards = symval;
        unsigned int i;
 
        device_id_check(mod->name, "pnp", size, id_size, symval);
 
        for (i = 0; i < count; i++) {
                unsigned int j;
-               const struct pnp_card_device_id *card = &cards[i];
+               DEF_FIELD_ADDR(symval + i*id_size, pnp_card_device_id, devs);
 
                for (j = 0; j < PNP_MAX_DEVICES; j++) {
-                       const char *id = (char *)card->devs[j].id;
+                       const char *id = (char *)(*devs)[j].id;
                        int i2, j2;
                        int dup = 0;
 
@@ -545,10 +568,10 @@ static void do_pnp_card_entries(void *symval, unsigned long size,
 
                        /* find duplicate, already added value */
                        for (i2 = 0; i2 < i && !dup; i2++) {
-                               const struct pnp_card_device_id *card2 = &cards[i2];
+                               DEF_FIELD_ADDR(symval + i2*id_size, pnp_card_device_id, devs);
 
                                for (j2 = 0; j2 < PNP_MAX_DEVICES; j2++) {
-                                       const char *id2 = (char *)card2->devs[j2].id;
+                                       const char *id2 = (char *)(*devs)[j2].id;
 
                                        if (!id2[0])
                                                break;
@@ -562,7 +585,7 @@ static void do_pnp_card_entries(void *symval, unsigned long size,
 
                        /* add an individual alias for every device entry */
                        if (!dup) {
-                               char acpi_id[sizeof(card->devs[0].id)];
+                               char acpi_id[PNP_ID_LEN];
                                int k;
 
                                buf_printf(&mod->dev_table_buf,
@@ -580,54 +603,58 @@ static void do_pnp_card_entries(void *symval, unsigned long size,
 
 /* Looks like: pcmcia:mNcNfNfnNpfnNvaNvbNvcNvdN. */
 static int do_pcmcia_entry(const char *filename,
-                          struct pcmcia_device_id *id, char *alias)
+                          void *symval, char *alias)
 {
        unsigned int i;
-
-       id->match_flags = TO_NATIVE(id->match_flags);
-       id->manf_id = TO_NATIVE(id->manf_id);
-       id->card_id = TO_NATIVE(id->card_id);
-       id->func_id = TO_NATIVE(id->func_id);
-       id->function = TO_NATIVE(id->function);
-       id->device_no = TO_NATIVE(id->device_no);
+       DEF_FIELD(symval, pcmcia_device_id, match_flags);
+       DEF_FIELD(symval, pcmcia_device_id, manf_id);
+       DEF_FIELD(symval, pcmcia_device_id, card_id);
+       DEF_FIELD(symval, pcmcia_device_id, func_id);
+       DEF_FIELD(symval, pcmcia_device_id, function);
+       DEF_FIELD(symval, pcmcia_device_id, device_no);
+       DEF_FIELD_ADDR(symval, pcmcia_device_id, prod_id_hash);
 
        for (i=0; i<4; i++) {
-               id->prod_id_hash[i] = TO_NATIVE(id->prod_id_hash[i]);
-       }
-
-       strcpy(alias, "pcmcia:");
-       ADD(alias, "m", id->match_flags & PCMCIA_DEV_ID_MATCH_MANF_ID,
-          id->manf_id);
-       ADD(alias, "c", id->match_flags & PCMCIA_DEV_ID_MATCH_CARD_ID,
-          id->card_id);
-       ADD(alias, "f", id->match_flags & PCMCIA_DEV_ID_MATCH_FUNC_ID,
-          id->func_id);
-       ADD(alias, "fn", id->match_flags & PCMCIA_DEV_ID_MATCH_FUNCTION,
-          id->function);
-       ADD(alias, "pfn", id->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO,
-          id->device_no);
-       ADD(alias, "pa", id->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID1, id->prod_id_hash[0]);
-       ADD(alias, "pb", id->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID2, id->prod_id_hash[1]);
-       ADD(alias, "pc", id->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID3, id->prod_id_hash[2]);
-       ADD(alias, "pd", id->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID4, id->prod_id_hash[3]);
+               (*prod_id_hash)[i] = TO_NATIVE((*prod_id_hash)[i]);
+       }
+
+       strcpy(alias, "pcmcia:");
+       ADD(alias, "m", match_flags & PCMCIA_DEV_ID_MATCH_MANF_ID,
+           manf_id);
+       ADD(alias, "c", match_flags & PCMCIA_DEV_ID_MATCH_CARD_ID,
+           card_id);
+       ADD(alias, "f", match_flags & PCMCIA_DEV_ID_MATCH_FUNC_ID,
+           func_id);
+       ADD(alias, "fn", match_flags & PCMCIA_DEV_ID_MATCH_FUNCTION,
+           function);
+       ADD(alias, "pfn", match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO,
+           device_no);
+       ADD(alias, "pa", match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID1, (*prod_id_hash)[0]);
+       ADD(alias, "pb", match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID2, (*prod_id_hash)[1]);
+       ADD(alias, "pc", match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID3, (*prod_id_hash)[2]);
+       ADD(alias, "pd", match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID4, (*prod_id_hash)[3]);
 
        add_wildcard(alias);
-       return 1;
+       return 1;
 }
-ADD_TO_DEVTABLE("pcmcia", struct pcmcia_device_id, do_pcmcia_entry);
+ADD_TO_DEVTABLE("pcmcia", pcmcia_device_id, do_pcmcia_entry);
 
-static int do_of_entry (const char *filename, struct of_device_id *of, char *alias)
+static int do_of_entry (const char *filename, void *symval, char *alias)
 {
     int len;
     char *tmp;
+    DEF_FIELD_ADDR(symval, of_device_id, name);
+    DEF_FIELD_ADDR(symval, of_device_id, type);
+    DEF_FIELD_ADDR(symval, of_device_id, compatible);
+
     len = sprintf (alias, "of:N%sT%s",
-                    of->name[0] ? of->name : "*",
-                    of->type[0] ? of->type : "*");
+                    (*name)[0] ? *name : "*",
+                    (*type)[0] ? *type : "*");
 
-    if (of->compatible[0])
+    if (compatible[0])
         sprintf (&alias[len], "%sC%s",
-                     of->type[0] ? "*" : "",
-                     of->compatible);
+                     (*type)[0] ? "*" : "",
+                     *compatible);
 
     /* Replace all whitespace with underscores */
     for (tmp = alias; tmp && *tmp; tmp++)
@@ -637,15 +664,17 @@ static int do_of_entry (const char *filename, struct of_device_id *of, char *ali
     add_wildcard(alias);
     return 1;
 }
-ADD_TO_DEVTABLE("of", struct of_device_id, do_of_entry);
+ADD_TO_DEVTABLE("of", of_device_id, do_of_entry);
 
-static int do_vio_entry(const char *filename, struct vio_device_id *vio,
+static int do_vio_entry(const char *filename, void *symval,
                char *alias)
 {
        char *tmp;
+       DEF_FIELD_ADDR(symval, vio_device_id, type);
+       DEF_FIELD_ADDR(symval, vio_device_id, compat);
 
-       sprintf(alias, "vio:T%sS%s", vio->type[0] ? vio->type : "*",
-                       vio->compat[0] ? vio->compat : "*");
+       sprintf(alias, "vio:T%sS%s", (*type)[0] ? *type : "*",
+                       (*compat)[0] ? *compat : "*");
 
        /* Replace all whitespace with underscores */
        for (tmp = alias; tmp && *tmp; tmp++)
@@ -655,7 +684,7 @@ static int do_vio_entry(const char *filename, struct vio_device_id *vio,
        add_wildcard(alias);
        return 1;
 }
-ADD_TO_DEVTABLE("vio", struct vio_device_id, do_vio_entry);
+ADD_TO_DEVTABLE("vio", vio_device_id, do_vio_entry);
 
 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
 
@@ -664,154 +693,172 @@ static void do_input(char *alias,
 {
        unsigned int i;
 
+       for (i = min / BITS_PER_LONG; i < max / BITS_PER_LONG + 1; i++)
+               arr[i] = TO_NATIVE(arr[i]);
        for (i = min; i < max; i++)
                if (arr[i / BITS_PER_LONG] & (1L << (i%BITS_PER_LONG)))
                        sprintf(alias + strlen(alias), "%X,*", i);
 }
 
 /* input:b0v0p0e0-eXkXrXaXmXlXsXfXwX where X is comma-separated %02X. */
-static int do_input_entry(const char *filename, struct input_device_id *id,
+static int do_input_entry(const char *filename, void *symval,
                          char *alias)
 {
+       DEF_FIELD(symval, input_device_id, flags);
+       DEF_FIELD(symval, input_device_id, bustype);
+       DEF_FIELD(symval, input_device_id, vendor);
+       DEF_FIELD(symval, input_device_id, product);
+       DEF_FIELD(symval, input_device_id, version);
+       DEF_FIELD_ADDR(symval, input_device_id, evbit);
+       DEF_FIELD_ADDR(symval, input_device_id, keybit);
+       DEF_FIELD_ADDR(symval, input_device_id, relbit);
+       DEF_FIELD_ADDR(symval, input_device_id, absbit);
+       DEF_FIELD_ADDR(symval, input_device_id, mscbit);
+       DEF_FIELD_ADDR(symval, input_device_id, ledbit);
+       DEF_FIELD_ADDR(symval, input_device_id, sndbit);
+       DEF_FIELD_ADDR(symval, input_device_id, ffbit);
+       DEF_FIELD_ADDR(symval, input_device_id, swbit);
+
        sprintf(alias, "input:");
 
-       ADD(alias, "b", id->flags & INPUT_DEVICE_ID_MATCH_BUS, id->bustype);
-       ADD(alias, "v", id->flags & INPUT_DEVICE_ID_MATCH_VENDOR, id->vendor);
-       ADD(alias, "p", id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT, id->product);
-       ADD(alias, "e", id->flags & INPUT_DEVICE_ID_MATCH_VERSION, id->version);
+       ADD(alias, "b", flags & INPUT_DEVICE_ID_MATCH_BUS, bustype);
+       ADD(alias, "v", flags & INPUT_DEVICE_ID_MATCH_VENDOR, vendor);
+       ADD(alias, "p", flags & INPUT_DEVICE_ID_MATCH_PRODUCT, product);
+       ADD(alias, "e", flags & INPUT_DEVICE_ID_MATCH_VERSION, version);
 
        sprintf(alias + strlen(alias), "-e*");
-       if (id->flags & INPUT_DEVICE_ID_MATCH_EVBIT)
-               do_input(alias, id->evbit, 0, INPUT_DEVICE_ID_EV_MAX);
+       if (flags & INPUT_DEVICE_ID_MATCH_EVBIT)
+               do_input(alias, *evbit, 0, INPUT_DEVICE_ID_EV_MAX);
        sprintf(alias + strlen(alias), "k*");
-       if (id->flags & INPUT_DEVICE_ID_MATCH_KEYBIT)
-               do_input(alias, id->keybit,
+       if (flags & INPUT_DEVICE_ID_MATCH_KEYBIT)
+               do_input(alias, *keybit,
                         INPUT_DEVICE_ID_KEY_MIN_INTERESTING,
                         INPUT_DEVICE_ID_KEY_MAX);
        sprintf(alias + strlen(alias), "r*");
-       if (id->flags & INPUT_DEVICE_ID_MATCH_RELBIT)
-               do_input(alias, id->relbit, 0, INPUT_DEVICE_ID_REL_MAX);
+       if (flags & INPUT_DEVICE_ID_MATCH_RELBIT)
+               do_input(alias, *relbit, 0, INPUT_DEVICE_ID_REL_MAX);
        sprintf(alias + strlen(alias), "a*");
-       if (id->flags & INPUT_DEVICE_ID_MATCH_ABSBIT)
-               do_input(alias, id->absbit, 0, INPUT_DEVICE_ID_ABS_MAX);
+       if (flags & INPUT_DEVICE_ID_MATCH_ABSBIT)
+               do_input(alias, *absbit, 0, INPUT_DEVICE_ID_ABS_MAX);
        sprintf(alias + strlen(alias), "m*");
-       if (id->flags & INPUT_DEVICE_ID_MATCH_MSCIT)
-               do_input(alias, id->mscbit, 0, INPUT_DEVICE_ID_MSC_MAX);
+       if (flags & INPUT_DEVICE_ID_MATCH_MSCIT)
+               do_input(alias, *mscbit, 0, INPUT_DEVICE_ID_MSC_MAX);
        sprintf(alias + strlen(alias), "l*");
-       if (id->flags & INPUT_DEVICE_ID_MATCH_LEDBIT)
-               do_input(alias, id->ledbit, 0, INPUT_DEVICE_ID_LED_MAX);
+       if (flags & INPUT_DEVICE_ID_MATCH_LEDBIT)
+               do_input(alias, *ledbit, 0, INPUT_DEVICE_ID_LED_MAX);
        sprintf(alias + strlen(alias), "s*");
-       if (id->flags & INPUT_DEVICE_ID_MATCH_SNDBIT)
-               do_input(alias, id->sndbit, 0, INPUT_DEVICE_ID_SND_MAX);
+       if (flags & INPUT_DEVICE_ID_MATCH_SNDBIT)
+               do_input(alias, *sndbit, 0, INPUT_DEVICE_ID_SND_MAX);
        sprintf(alias + strlen(alias), "f*");
-       if (id->flags & INPUT_DEVICE_ID_MATCH_FFBIT)
-               do_input(alias, id->ffbit, 0, INPUT_DEVICE_ID_FF_MAX);
+       if (flags & INPUT_DEVICE_ID_MATCH_FFBIT)
+               do_input(alias, *ffbit, 0, INPUT_DEVICE_ID_FF_MAX);
        sprintf(alias + strlen(alias), "w*");
-       if (id->flags & INPUT_DEVICE_ID_MATCH_SWBIT)
-               do_input(alias, id->swbit, 0, INPUT_DEVICE_ID_SW_MAX);
+       if (flags & INPUT_DEVICE_ID_MATCH_SWBIT)
+               do_input(alias, *swbit, 0, INPUT_DEVICE_ID_SW_MAX);
        return 1;
 }
-ADD_TO_DEVTABLE("input", struct input_device_id, do_input_entry);
+ADD_TO_DEVTABLE("input", input_device_id, do_input_entry);
 
-static int do_eisa_entry(const char *filename, struct eisa_device_id *eisa,
+static int do_eisa_entry(const char *filename, void *symval,
                char *alias)
 {
-       if (eisa->sig[0])
-               sprintf(alias, EISA_DEVICE_MODALIAS_FMT "*", eisa->sig);
+       DEF_FIELD_ADDR(symval, eisa_device_id, sig);
+       if (sig[0])
+               sprintf(alias, EISA_DEVICE_MODALIAS_FMT "*", *sig);
        else
                strcat(alias, "*");
        return 1;
 }
-ADD_TO_DEVTABLE("eisa", struct eisa_device_id, do_eisa_entry);
+ADD_TO_DEVTABLE("eisa", eisa_device_id, do_eisa_entry);
 
 /* Looks like: parisc:tNhvNrevNsvN */
-static int do_parisc_entry(const char *filename, struct parisc_device_id *id,
+static int do_parisc_entry(const char *filename, void *symval,
                char *alias)
 {
-       id->hw_type = TO_NATIVE(id->hw_type);
-       id->hversion = TO_NATIVE(id->hversion);
-       id->hversion_rev = TO_NATIVE(id->hversion_rev);
-       id->sversion = TO_NATIVE(id->sversion);
+       DEF_FIELD(symval, parisc_device_id, hw_type);
+       DEF_FIELD(symval, parisc_device_id, hversion);
+       DEF_FIELD(symval, parisc_device_id, hversion_rev);
+       DEF_FIELD(symval, parisc_device_id, sversion);
 
        strcpy(alias, "parisc:");
-       ADD(alias, "t", id->hw_type != PA_HWTYPE_ANY_ID, id->hw_type);
-       ADD(alias, "hv", id->hversion != PA_HVERSION_ANY_ID, id->hversion);
-       ADD(alias, "rev", id->hversion_rev != PA_HVERSION_REV_ANY_ID, id->hversion_rev);
-       ADD(alias, "sv", id->sversion != PA_SVERSION_ANY_ID, id->sversion);
+       ADD(alias, "t", hw_type != PA_HWTYPE_ANY_ID, hw_type);
+       ADD(alias, "hv", hversion != PA_HVERSION_ANY_ID, hversion);
+       ADD(alias, "rev", hversion_rev != PA_HVERSION_REV_ANY_ID, hversion_rev);
+       ADD(alias, "sv", sversion != PA_SVERSION_ANY_ID, sversion);
 
        add_wildcard(alias);
        return 1;
 }
-ADD_TO_DEVTABLE("parisc", struct parisc_device_id, do_parisc_entry);
+ADD_TO_DEVTABLE("parisc", parisc_device_id, do_parisc_entry);
 
 /* Looks like: sdio:cNvNdN. */
 static int do_sdio_entry(const char *filename,
-                       struct sdio_device_id *id, char *alias)
+                       void *symval, char *alias)
 {
-       id->class = TO_NATIVE(id->class);
-       id->vendor = TO_NATIVE(id->vendor);
-       id->device = TO_NATIVE(id->device);
+       DEF_FIELD(symval, sdio_device_id, class);
+       DEF_FIELD(symval, sdio_device_id, vendor);
+       DEF_FIELD(symval, sdio_device_id, device);
 
        strcpy(alias, "sdio:");
-       ADD(alias, "c", id->class != (__u8)SDIO_ANY_ID, id->class);
-       ADD(alias, "v", id->vendor != (__u16)SDIO_ANY_ID, id->vendor);
-       ADD(alias, "d", id->device != (__u16)SDIO_ANY_ID, id->device);
+       ADD(alias, "c", class != (__u8)SDIO_ANY_ID, class);
+       ADD(alias, "v", vendor != (__u16)SDIO_ANY_ID, vendor);
+       ADD(alias, "d", device != (__u16)SDIO_ANY_ID, device);
        add_wildcard(alias);
        return 1;
 }
-ADD_TO_DEVTABLE("sdio", struct sdio_device_id, do_sdio_entry);
+ADD_TO_DEVTABLE("sdio", sdio_device_id, do_sdio_entry);
 
 /* Looks like: ssb:vNidNrevN. */
 static int do_ssb_entry(const char *filename,
-                       struct ssb_device_id *id, char *alias)
+                       void *symval, char *alias)
 {
-       id->vendor = TO_NATIVE(id->vendor);
-       id->coreid = TO_NATIVE(id->coreid);
-       id->revision = TO_NATIVE(id->revision);
+       DEF_FIELD(symval, ssb_device_id, vendor);
+       DEF_FIELD(symval, ssb_device_id, coreid);
+       DEF_FIELD(symval, ssb_device_id, revision);
 
        strcpy(alias, "ssb:");
-       ADD(alias, "v", id->vendor != SSB_ANY_VENDOR, id->vendor);
-       ADD(alias, "id", id->coreid != SSB_ANY_ID, id->coreid);
-       ADD(alias, "rev", id->revision != SSB_ANY_REV, id->revision);
+       ADD(alias, "v", vendor != SSB_ANY_VENDOR, vendor);
+       ADD(alias, "id", coreid != SSB_ANY_ID, coreid);
+       ADD(alias, "rev", revision != SSB_ANY_REV, revision);
        add_wildcard(alias);
        return 1;
 }
-ADD_TO_DEVTABLE("ssb", struct ssb_device_id, do_ssb_entry);
+ADD_TO_DEVTABLE("ssb", ssb_device_id, do_ssb_entry);
 
 /* Looks like: bcma:mNidNrevNclN. */
 static int do_bcma_entry(const char *filename,
-                        struct bcma_device_id *id, char *alias)
+                        void *symval, char *alias)
 {
-       id->manuf = TO_NATIVE(id->manuf);
-       id->id = TO_NATIVE(id->id);
-       id->rev = TO_NATIVE(id->rev);
-       id->class = TO_NATIVE(id->class);
+       DEF_FIELD(symval, bcma_device_id, manuf);
+       DEF_FIELD(symval, bcma_device_id, id);
+       DEF_FIELD(symval, bcma_device_id, rev);
+       DEF_FIELD(symval, bcma_device_id, class);
 
        strcpy(alias, "bcma:");
-       ADD(alias, "m", id->manuf != BCMA_ANY_MANUF, id->manuf);
-       ADD(alias, "id", id->id != BCMA_ANY_ID, id->id);
-       ADD(alias, "rev", id->rev != BCMA_ANY_REV, id->rev);
-       ADD(alias, "cl", id->class != BCMA_ANY_CLASS, id->class);
+       ADD(alias, "m", manuf != BCMA_ANY_MANUF, manuf);
+       ADD(alias, "id", id != BCMA_ANY_ID, id);
+       ADD(alias, "rev", rev != BCMA_ANY_REV, rev);
+       ADD(alias, "cl", class != BCMA_ANY_CLASS, class);
        add_wildcard(alias);
        return 1;
 }
-ADD_TO_DEVTABLE("bcma", struct bcma_device_id, do_bcma_entry);
+ADD_TO_DEVTABLE("bcma", bcma_device_id, do_bcma_entry);
 
 /* Looks like: virtio:dNvN */
-static int do_virtio_entry(const char *filename, struct virtio_device_id *id,
+static int do_virtio_entry(const char *filename, void *symval,
                           char *alias)
 {
-       id->device = TO_NATIVE(id->device);
-       id->vendor = TO_NATIVE(id->vendor);
+       DEF_FIELD(symval, virtio_device_id, device);
+       DEF_FIELD(symval, virtio_device_id, vendor);
 
        strcpy(alias, "virtio:");
-       ADD(alias, "d", id->device != VIRTIO_DEV_ANY_ID, id->device);
-       ADD(alias, "v", id->vendor != VIRTIO_DEV_ANY_ID, id->vendor);
+       ADD(alias, "d", device != VIRTIO_DEV_ANY_ID, device);
+       ADD(alias, "v", vendor != VIRTIO_DEV_ANY_ID, vendor);
 
        add_wildcard(alias);
        return 1;
 }
-ADD_TO_DEVTABLE("virtio", struct virtio_device_id, do_virtio_entry);
+ADD_TO_DEVTABLE("virtio", virtio_device_id, do_virtio_entry);
 
 /*
  * Looks like: vmbus:guid
@@ -819,41 +866,44 @@ ADD_TO_DEVTABLE("virtio", struct virtio_device_id, do_virtio_entry);
  * in the name.
  */
 
-static int do_vmbus_entry(const char *filename, struct hv_vmbus_device_id *id,
+static int do_vmbus_entry(const char *filename, void *symval,
                          char *alias)
 {
        int i;
-       char guid_name[((sizeof(id->guid) + 1)) * 2];
+       DEF_FIELD_ADDR(symval, hv_vmbus_device_id, guid);
+       char guid_name[(sizeof(*guid) + 1) * 2];
 
-       for (i = 0; i < (sizeof(id->guid) * 2); i += 2)
-               sprintf(&guid_name[i], "%02x", id->guid[i/2]);
+       for (i = 0; i < (sizeof(*guid) * 2); i += 2)
+               sprintf(&guid_name[i], "%02x", TO_NATIVE((*guid)[i/2]));
 
        strcpy(alias, "vmbus:");
        strcat(alias, guid_name);
 
        return 1;
 }
-ADD_TO_DEVTABLE("vmbus", struct hv_vmbus_device_id, do_vmbus_entry);
+ADD_TO_DEVTABLE("vmbus", hv_vmbus_device_id, do_vmbus_entry);
 
 /* Looks like: i2c:S */
-static int do_i2c_entry(const char *filename, struct i2c_device_id *id,
+static int do_i2c_entry(const char *filename, void *symval,
                        char *alias)
 {
-       sprintf(alias, I2C_MODULE_PREFIX "%s", id->name);
+       DEF_FIELD_ADDR(symval, i2c_device_id, name);
+       sprintf(alias, I2C_MODULE_PREFIX "%s", *name);
 
        return 1;
 }
-ADD_TO_DEVTABLE("i2c", struct i2c_device_id, do_i2c_entry);
+ADD_TO_DEVTABLE("i2c", i2c_device_id, do_i2c_entry);
 
 /* Looks like: spi:S */
-static int do_spi_entry(const char *filename, struct spi_device_id *id,
+static int do_spi_entry(const char *filename, void *symval,
                        char *alias)
 {
-       sprintf(alias, SPI_MODULE_PREFIX "%s", id->name);
+       DEF_FIELD_ADDR(symval, spi_device_id, name);
+       sprintf(alias, SPI_MODULE_PREFIX "%s", *name);
 
        return 1;
 }
-ADD_TO_DEVTABLE("spi", struct spi_device_id, do_spi_entry);
+ADD_TO_DEVTABLE("spi", spi_device_id, do_spi_entry);
 
 static const struct dmifield {
        const char *prefix;
@@ -885,21 +935,21 @@ static void dmi_ascii_filter(char *d, const char *s)
 }
 
 
-static int do_dmi_entry(const char *filename, struct dmi_system_id *id,
+static int do_dmi_entry(const char *filename, void *symval,
                        char *alias)
 {
        int i, j;
-
+       DEF_FIELD_ADDR(symval, dmi_system_id, matches);
        sprintf(alias, "dmi*");
 
        for (i = 0; i < ARRAY_SIZE(dmi_fields); i++) {
                for (j = 0; j < 4; j++) {
-                       if (id->matches[j].slot &&
-                           id->matches[j].slot == dmi_fields[i].field) {
+                       if ((*matches)[j].slot &&
+                           (*matches)[j].slot == dmi_fields[i].field) {
                                sprintf(alias + strlen(alias), ":%s*",
                                        dmi_fields[i].prefix);
                                dmi_ascii_filter(alias + strlen(alias),
-                                                id->matches[j].substr);
+                                                (*matches)[j].substr);
                                strcat(alias, "*");
                        }
                }
@@ -908,27 +958,30 @@ static int do_dmi_entry(const char *filename, struct dmi_system_id *id,
        strcat(alias, ":");
        return 1;
 }
-ADD_TO_DEVTABLE("dmi", struct dmi_system_id, do_dmi_entry);
+ADD_TO_DEVTABLE("dmi", dmi_system_id, do_dmi_entry);
 
 static int do_platform_entry(const char *filename,
-                            struct platform_device_id *id, char *alias)
+                            void *symval, char *alias)
 {
-       sprintf(alias, PLATFORM_MODULE_PREFIX "%s", id->name);
+       DEF_FIELD_ADDR(symval, platform_device_id, name);
+       sprintf(alias, PLATFORM_MODULE_PREFIX "%s", *name);
        return 1;
 }
-ADD_TO_DEVTABLE("platform", struct platform_device_id, do_platform_entry);
+ADD_TO_DEVTABLE("platform", platform_device_id, do_platform_entry);
 
 static int do_mdio_entry(const char *filename,
-                        struct mdio_device_id *id, char *alias)
+                        void *symval, char *alias)
 {
        int i;
+       DEF_FIELD(symval, mdio_device_id, phy_id);
+       DEF_FIELD(symval, mdio_device_id, phy_id_mask);
 
        alias += sprintf(alias, MDIO_MODULE_PREFIX);
 
        for (i = 0; i < 32; i++) {
-               if (!((id->phy_id_mask >> (31-i)) & 1))
+               if (!((phy_id_mask >> (31-i)) & 1))
                        *(alias++) = '?';
-               else if ((id->phy_id >> (31-i)) & 1)
+               else if ((phy_id >> (31-i)) & 1)
                        *(alias++) = '1';
                else
                        *(alias++) = '0';
@@ -939,47 +992,50 @@ static int do_mdio_entry(const char *filename,
 
        return 1;
 }
-ADD_TO_DEVTABLE("mdio", struct mdio_device_id, do_mdio_entry);
+ADD_TO_DEVTABLE("mdio", mdio_device_id, do_mdio_entry);
 
 /* Looks like: zorro:iN. */
-static int do_zorro_entry(const char *filename, struct zorro_device_id *id,
+static int do_zorro_entry(const char *filename, void *symval,
                          char *alias)
 {
-       id->id = TO_NATIVE(id->id);
+       DEF_FIELD(symval, zorro_device_id, id);
        strcpy(alias, "zorro:");
-       ADD(alias, "i", id->id != ZORRO_WILDCARD, id->id);
+       ADD(alias, "i", id != ZORRO_WILDCARD, id);
        return 1;
 }
-ADD_TO_DEVTABLE("zorro", struct zorro_device_id, do_zorro_entry);
+ADD_TO_DEVTABLE("zorro", zorro_device_id, do_zorro_entry);
 
 /* looks like: "pnp:dD" */
 static int do_isapnp_entry(const char *filename,
-                          struct isapnp_device_id *id, char *alias)
+                          void *symval, char *alias)
 {
+       DEF_FIELD(symval, isapnp_device_id, vendor);
+       DEF_FIELD(symval, isapnp_device_id, function);
        sprintf(alias, "pnp:d%c%c%c%x%x%x%x*",
-               'A' + ((id->vendor >> 2) & 0x3f) - 1,
-               'A' + (((id->vendor & 3) << 3) | ((id->vendor >> 13) & 7)) - 1,
-               'A' + ((id->vendor >> 8) & 0x1f) - 1,
-               (id->function >> 4) & 0x0f, id->function & 0x0f,
-               (id->function >> 12) & 0x0f, (id->function >> 8) & 0x0f);
+               'A' + ((vendor >> 2) & 0x3f) - 1,
+               'A' + (((vendor & 3) << 3) | ((vendor >> 13) & 7)) - 1,
+               'A' + ((vendor >> 8) & 0x1f) - 1,
+               (function >> 4) & 0x0f, function & 0x0f,
+               (function >> 12) & 0x0f, (function >> 8) & 0x0f);
        return 1;
 }
-ADD_TO_DEVTABLE("isapnp", struct isapnp_device_id, do_isapnp_entry);
+ADD_TO_DEVTABLE("isapnp", isapnp_device_id, do_isapnp_entry);
 
 /* Looks like: "ipack:fNvNdN". */
 static int do_ipack_entry(const char *filename,
-                         struct ipack_device_id *id, char *alias)
+                         void *symval, char *alias)
 {
-       id->vendor = TO_NATIVE(id->vendor);
-       id->device = TO_NATIVE(id->device);
+       DEF_FIELD(symval, ipack_device_id, format);
+       DEF_FIELD(symval, ipack_device_id, vendor);
+       DEF_FIELD(symval, ipack_device_id, device);
        strcpy(alias, "ipack:");
-       ADD(alias, "f", id->format != IPACK_ANY_FORMAT, id->format);
-       ADD(alias, "v", id->vendor != IPACK_ANY_ID, id->vendor);
-       ADD(alias, "d", id->device != IPACK_ANY_ID, id->device);
+       ADD(alias, "f", format != IPACK_ANY_FORMAT, format);
+       ADD(alias, "v", vendor != IPACK_ANY_ID, vendor);
+       ADD(alias, "d", device != IPACK_ANY_ID, device);
        add_wildcard(alias);
        return 1;
 }
-ADD_TO_DEVTABLE("ipack", struct ipack_device_id, do_ipack_entry);
+ADD_TO_DEVTABLE("ipack", ipack_device_id, do_ipack_entry);
 
 /*
  * Append a match expression for a single masked hex digit.
@@ -1030,25 +1086,27 @@ static void append_nibble_mask(char **outp,
  *     a ? or [] pattern matching exactly one digit.
  */
 static int do_amba_entry(const char *filename,
-                        struct amba_id *id, char *alias)
+                        void *symval, char *alias)
 {
        unsigned int digit;
        char *p = alias;
+       DEF_FIELD(symval, amba_id, id);
+       DEF_FIELD(symval, amba_id, mask);
 
-       if ((id->id & id->mask) != id->id)
+       if ((id & mask) != id)
                fatal("%s: Masked-off bit(s) of AMBA device ID are non-zero: "
                      "id=0x%08X, mask=0x%08X.  Please fix this driver.\n",
-                     filename, id->id, id->mask);
+                     filename, idmask);
 
        p += sprintf(alias, "amba:d");
        for (digit = 0; digit < 8; digit++)
                append_nibble_mask(&p,
-                                  (id->id >> (4 * (7 - digit))) & 0xf,
-                                  (id->mask >> (4 * (7 - digit))) & 0xf);
+                                  (id >> (4 * (7 - digit))) & 0xf,
+                                  (mask >> (4 * (7 - digit))) & 0xf);
 
        return 1;
 }
-ADD_TO_DEVTABLE("amba", struct amba_id, do_amba_entry);
+ADD_TO_DEVTABLE("amba", amba_id, do_amba_entry);
 
 /* LOOKS like x86cpu:vendor:VVVV:family:FFFF:model:MMMM:feature:*,FEAT,*
  * All fields are numbers. It would be nicer to use strings for vendor
@@ -1056,24 +1114,24 @@ ADD_TO_DEVTABLE("amba", struct amba_id, do_amba_entry);
  * complicated.
  */
 
-static int do_x86cpu_entry(const char *filename, struct x86_cpu_id *id,
+static int do_x86cpu_entry(const char *filename, void *symval,
                           char *alias)
 {
-       id->feature = TO_NATIVE(id->feature);
-       id->family = TO_NATIVE(id->family);
-       id->model = TO_NATIVE(id->model);
-       id->vendor = TO_NATIVE(id->vendor);
+       DEF_FIELD(symval, x86_cpu_id, feature);
+       DEF_FIELD(symval, x86_cpu_id, family);
+       DEF_FIELD(symval, x86_cpu_id, model);
+       DEF_FIELD(symval, x86_cpu_id, vendor);
 
        strcpy(alias, "x86cpu:");
-       ADD(alias, "vendor:",  id->vendor != X86_VENDOR_ANY, id->vendor);
-       ADD(alias, ":family:", id->family != X86_FAMILY_ANY, id->family);
-       ADD(alias, ":model:",  id->model  != X86_MODEL_ANY,  id->model);
+       ADD(alias, "vendor:",  vendor != X86_VENDOR_ANY, vendor);
+       ADD(alias, ":family:", family != X86_FAMILY_ANY, family);
+       ADD(alias, ":model:",  model  != X86_MODEL_ANY,  model);
        strcat(alias, ":feature:*");
-       if (id->feature != X86_FEATURE_ANY)
-               sprintf(alias + strlen(alias), "%04X*", id->feature);
+       if (feature != X86_FEATURE_ANY)
+               sprintf(alias + strlen(alias), "%04X*", feature);
        return 1;
 }
-ADD_TO_DEVTABLE("x86cpu", struct x86_cpu_id, do_x86cpu_entry);
+ADD_TO_DEVTABLE("x86cpu", x86_cpu_id, do_x86cpu_entry);
 
 /* Does namelen bytes of name exactly match the symbol? */
 static bool sym_is(const char *name, unsigned namelen, const char *symbol)
index 1c6fbb1..78b30c1 100644 (file)
@@ -2128,7 +2128,7 @@ int main(int argc, char **argv)
        struct ext_sym_list *extsym_iter;
        struct ext_sym_list *extsym_start = NULL;
 
-       while ((opt = getopt(argc, argv, "i:I:e:cmsSo:awM:K:")) != -1) {
+       while ((opt = getopt(argc, argv, "i:I:e:msSo:awM:K:")) != -1) {
                switch (opt) {
                case 'i':
                        kernel_read = optarg;
@@ -2137,9 +2137,6 @@ int main(int argc, char **argv)
                        module_read = optarg;
                        external_module = 1;
                        break;
-               case 'c':
-                       cross_build = 1;
-                       break;
                case 'e':
                        external_module = 1;
                        extsym_iter =
index 4bf17dd..fbbfd08 100755 (executable)
@@ -95,7 +95,7 @@ echo 'cp $KBUILD_IMAGE $RPM_BUILD_ROOT'"/boot/vmlinuz-$KERNELRELEASE"
 echo "%endif"
 echo "%endif"
 
-echo 'make %{?_smp_mflags} INSTALL_HDR_PATH=$RPM_BUILD_ROOT/usr headers_install'
+echo 'make %{?_smp_mflags} INSTALL_HDR_PATH=$RPM_BUILD_ROOT/usr KBUILD_SRC= headers_install'
 echo 'cp System.map $RPM_BUILD_ROOT'"/boot/System.map-$KERNELRELEASE"
 
 echo 'cp .config $RPM_BUILD_ROOT'"/boot/config-$KERNELRELEASE"
index bd6dca8..84b88f1 100755 (executable)
@@ -108,7 +108,7 @@ scm_version()
        fi
 
        # Check for svn and a svn repo.
-       if rev=`svn info 2>/dev/null | grep '^Last Changed Rev'`; then
+       if rev=`LANG= LC_ALL= LC_MESSAGES=C svn info 2>/dev/null | grep '^Last Changed Rev'`; then
                rev=`echo $rev | awk '{print $NF}'`
                printf -- '-svn%s' "$rev"
 
index 65f9595..26a87e6 100755 (executable)
@@ -217,34 +217,34 @@ exuberant()
 emacs()
 {
        all_target_sources | xargs $1 -a                        \
-       --regex='/^(ENTRY|_GLOBAL)(\([^)]*\)).*/\2/'            \
+       --regex='/^\(ENTRY\|_GLOBAL\)(\([^)]*\)).*/\2/'         \
        --regex='/^SYSCALL_DEFINE[0-9]?(\([^,)]*\).*/sys_\1/'   \
        --regex='/^TRACE_EVENT(\([^,)]*\).*/trace_\1/'          \
        --regex='/^DEFINE_EVENT([^,)]*, *\([^,)]*\).*/trace_\1/' \
-       --regex='/PAGEFLAG\(([^,)]*).*/Page\1/'                 \
-       --regex='/PAGEFLAG\(([^,)]*).*/SetPage\1/'              \
-       --regex='/PAGEFLAG\(([^,)]*).*/ClearPage\1/'            \
-       --regex='/TESTSETFLAG\(([^,)]*).*/TestSetPage\1/'       \
-       --regex='/TESTPAGEFLAG\(([^,)]*).*/Page\1/'             \
-       --regex='/SETPAGEFLAG\(([^,)]*).*/SetPage\1/'           \
-       --regex='/__SETPAGEFLAG\(([^,)]*).*/__SetPage\1/'       \
-       --regex='/TESTCLEARFLAG\(([^,)]*).*/TestClearPage\1/'   \
-       --regex='/__TESTCLEARFLAG\(([^,)]*).*/TestClearPage\1/' \
-       --regex='/CLEARPAGEFLAG\(([^,)]*).*/ClearPage\1/'       \
-       --regex='/__CLEARPAGEFLAG\(([^,)]*).*/__ClearPage\1/'   \
-       --regex='/__PAGEFLAG\(([^,)]*).*/__SetPage\1/'          \
-       --regex='/__PAGEFLAG\(([^,)]*).*/__ClearPage\1/'        \
-       --regex='/PAGEFLAG_FALSE\(([^,)]*).*/Page\1/'           \
-       --regex='/TESTSCFLAG\(([^,)]*).*/TestSetPage\1/'        \
-       --regex='/TESTSCFLAG\(([^,)]*).*/TestClearPage\1/'      \
-       --regex='/SETPAGEFLAG_NOOP\(([^,)]*).*/SetPage\1/'      \
-       --regex='/CLEARPAGEFLAG_NOOP\(([^,)]*).*/ClearPage\1/'  \
-       --regex='/__CLEARPAGEFLAG_NOOP\(([^,)]*).*/__ClearPage\1/' \
-       --regex='/TESTCLEARFLAG_FALSE\(([^,)]*).*/TestClearPage\1/' \
-       --regex='/__TESTCLEARFLAG_FALSE\(([^,)]*).*/__TestClearPage\1/' \
-       --regex='/_PE\(([^,)]*).*/PEVENT_ERRNO__\1/'            \
-       --regex='/PCI_OP_READ\(([a-z]*[a-z]).*[1-4]\)/pci_bus_read_config_\1/' \
-       --regex='/PCI_OP_WRITE\(([a-z]*[a-z]).*[1-4]\)/pci_bus_write_config_\1/'
+       --regex='/PAGEFLAG(\([^,)]*\).*/Page\1/'                        \
+       --regex='/PAGEFLAG(\([^,)]*\).*/SetPage\1/'             \
+       --regex='/PAGEFLAG(\([^,)]*\).*/ClearPage\1/'           \
+       --regex='/TESTSETFLAG(\([^,)]*\).*/TestSetPage\1/'      \
+       --regex='/TESTPAGEFLAG(\([^,)]*\).*/Page\1/'            \
+       --regex='/SETPAGEFLAG(\([^,)]*\).*/SetPage\1/'          \
+       --regex='/__SETPAGEFLAG(\([^,)]*\).*/__SetPage\1/'      \
+       --regex='/TESTCLEARFLAG(\([^,)]*\).*/TestClearPage\1/'  \
+       --regex='/__TESTCLEARFLAG(\([^,)]*\).*/TestClearPage\1/'        \
+       --regex='/CLEARPAGEFLAG(\([^,)]*\).*/ClearPage\1/'      \
+       --regex='/__CLEARPAGEFLAG(\([^,)]*\).*/__ClearPage\1/'  \
+       --regex='/__PAGEFLAG(\([^,)]*\).*/__SetPage\1/'         \
+       --regex='/__PAGEFLAG(\([^,)]*\).*/__ClearPage\1/'       \
+       --regex='/PAGEFLAG_FALSE(\([^,)]*\).*/Page\1/'          \
+       --regex='/TESTSCFLAG(\([^,)]*\).*/TestSetPage\1/'       \
+       --regex='/TESTSCFLAG(\([^,)]*\).*/TestClearPage\1/'     \
+       --regex='/SETPAGEFLAG_NOOP(\([^,)]*\).*/SetPage\1/'     \
+       --regex='/CLEARPAGEFLAG_NOOP(\([^,)]*\).*/ClearPage\1/' \
+       --regex='/__CLEARPAGEFLAG_NOOP(\([^,)]*\).*/__ClearPage\1/' \
+       --regex='/TESTCLEARFLAG_FALSE(\([^,)]*\).*/TestClearPage\1/' \
+       --regex='/__TESTCLEARFLAG_FALSE(\([^,)]*\).*/__TestClearPage\1/' \
+       --regex='/_PE(\([^,)]*\).*/PEVENT_ERRNO__\1/'           \
+       --regex='/PCI_OP_READ(\([a-z]*[a-z]\).*[1-4])/pci_bus_read_config_\1/' \
+       --regex='/PCI_OP_WRITE(\([a-z]*[a-z]\).*[1-4])/pci_bus_write_config_\1/'
 
        all_kconfigs | xargs $1 -a                              \
        --regex='/^[ \t]*\(\(menu\)*config\)[ \t]+\([a-zA-Z0-9_]+\)/\3/'
index cdd100d..9febe55 100644 (file)
@@ -836,6 +836,8 @@ static struct {
        {0x7063, 0x2000}, /* pcHDTV HD-2000 TV */
 };
 
+static struct pci_driver driver;
+
 /* return the id of the card, or a negative value if it's blacklisted */
 static int snd_bt87x_detect_card(struct pci_dev *pci)
 {
@@ -962,11 +964,24 @@ static DEFINE_PCI_DEVICE_TABLE(snd_bt87x_default_ids) = {
        { }
 };
 
-static struct pci_driver bt87x_driver = {
+static struct pci_driver driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_bt87x_ids,
        .probe = snd_bt87x_probe,
        .remove = snd_bt87x_remove,
 };
 
-module_pci_driver(bt87x_driver);
+static int __init alsa_card_bt87x_init(void)
+{
+       if (load_all)
+               driver.id_table = snd_bt87x_default_ids;
+       return pci_register_driver(&driver);
+}
+
+static void __exit alsa_card_bt87x_exit(void)
+{
+       pci_unregister_driver(&driver);
+}
+
+module_init(alsa_card_bt87x_init)
+module_exit(alsa_card_bt87x_exit)
index a7c296a..e6b0166 100644 (file)
@@ -862,6 +862,12 @@ static int snd_emu10k1_emu1010_init(struct snd_emu10k1 *emu)
                           filename, emu->firmware->size);
        }
 
+       err = snd_emu1010_load_firmware(emu);
+       if (err != 0) {
+               snd_printk(KERN_INFO "emu1010: Loading Firmware failed\n");
+               return err;
+       }
+
        /* ID, should read & 0x7f = 0x55 when FPGA programmed. */
        snd_emu1010_fpga_read(emu, EMU_HANA_ID, &reg);
        if ((reg & 0x3f) != 0x15) {
index 748a286..5ae1d04 100644 (file)
@@ -1127,7 +1127,7 @@ static int snd_emu10k1_playback_open(struct snd_pcm_substream *substream)
        struct snd_emu10k1_pcm *epcm;
        struct snd_emu10k1_pcm_mixer *mix;
        struct snd_pcm_runtime *runtime = substream->runtime;
-       int i, err;
+       int i, err, sample_rate;
 
        epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
        if (epcm == NULL)
@@ -1146,7 +1146,11 @@ static int snd_emu10k1_playback_open(struct snd_pcm_substream *substream)
                kfree(epcm);
                return err;
        }
-       err = snd_pcm_hw_rule_noresample(runtime, 48000);
+       if (emu->card_capabilities->emu_model && emu->emu1010.internal_clock == 0)
+               sample_rate = 44100;
+       else
+               sample_rate = 48000;
+       err = snd_pcm_hw_rule_noresample(runtime, sample_rate);
        if (err < 0) {
                kfree(epcm);
                return err;
index 21425fb..78e1827 100644 (file)
@@ -1640,6 +1640,9 @@ static int generic_hdmi_build_jack(struct hda_codec *codec, int pin_idx)
 
        if (pcmdev > 0)
                sprintf(hdmi_str + strlen(hdmi_str), ",pcm=%d", pcmdev);
+       if (!is_jack_detectable(codec, per_pin->pin_nid))
+               strncat(hdmi_str, " Phantom",
+                       sizeof(hdmi_str) - strlen(hdmi_str) - 1);
 
        return snd_hda_jack_add_kctl(codec, per_pin->pin_nid, hdmi_str, 0);
 }
index 61478fd..2d4237b 100644 (file)
@@ -928,6 +928,7 @@ static int alc_codec_rename_from_preset(struct hda_codec *codec)
 static const struct snd_pci_quirk beep_white_list[] = {
        SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),
        SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
+       SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1),
        SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
        SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
        SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
index 7641080..1112ec1 100644 (file)
@@ -35,6 +35,7 @@
 struct revo51_spec {
        struct snd_i2c_device *dev;
        struct snd_pt2258 *pt2258;
+       struct ak4114 *ak4114;
 };
 
 static void revo_i2s_mclk_changed(struct snd_ice1712 *ice)
@@ -359,9 +360,9 @@ static struct snd_ak4xxx_private akm_ap192_priv = {
        .cif = 0,
        .data_mask = VT1724_REVO_CDOUT,
        .clk_mask = VT1724_REVO_CCLK,
-       .cs_mask = VT1724_REVO_CS0 | VT1724_REVO_CS1,
-       .cs_addr = VT1724_REVO_CS1,
-       .cs_none = VT1724_REVO_CS0 | VT1724_REVO_CS1,
+       .cs_mask = VT1724_REVO_CS0 | VT1724_REVO_CS3,
+       .cs_addr = VT1724_REVO_CS3,
+       .cs_none = VT1724_REVO_CS0 | VT1724_REVO_CS3,
        .add_flags = VT1724_REVO_CCLK, /* high at init */
        .mask_flags = 0,
 };
@@ -372,7 +373,7 @@ static struct snd_ak4xxx_private akm_ap192_priv = {
  * CCLK (pin 34) -- GPIO1 pin 51 (shared with AK4358)
  * CSN  (pin 35) -- GPIO7 pin 59
  */
-#define AK4114_ADDR    0x02
+#define AK4114_ADDR    0x00
 
 static void write_data(struct snd_ice1712 *ice, unsigned int gpio,
                       unsigned int data, int idx)
@@ -426,7 +427,7 @@ static unsigned int ap192_4wire_start(struct snd_ice1712 *ice)
        tmp = snd_ice1712_gpio_read(ice);
        tmp |= VT1724_REVO_CCLK; /* high at init */
        tmp |= VT1724_REVO_CS0;
-       tmp &= ~VT1724_REVO_CS1;
+       tmp &= ~VT1724_REVO_CS3;
        snd_ice1712_gpio_write(ice, tmp);
        udelay(1);
        return tmp;
@@ -434,7 +435,7 @@ static unsigned int ap192_4wire_start(struct snd_ice1712 *ice)
 
 static void ap192_4wire_finish(struct snd_ice1712 *ice, unsigned int tmp)
 {
-       tmp |= VT1724_REVO_CS1;
+       tmp |= VT1724_REVO_CS3;
        tmp |= VT1724_REVO_CS0;
        snd_ice1712_gpio_write(ice, tmp);
        udelay(1);
@@ -470,27 +471,32 @@ static unsigned char ap192_ak4114_read(void *private_data, unsigned char addr)
 static int ap192_ak4114_init(struct snd_ice1712 *ice)
 {
        static const unsigned char ak4114_init_vals[] = {
-               AK4114_RST | AK4114_PWN | AK4114_OCKS0 | AK4114_OCKS1,
+               AK4114_RST | AK4114_PWN | AK4114_OCKS0,
                AK4114_DIF_I24I2S,
                AK4114_TX1E,
-               AK4114_EFH_1024 | AK4114_DIT | AK4114_IPS(1),
+               AK4114_EFH_1024 | AK4114_DIT | AK4114_IPS(0),
                0,
                0
        };
        static const unsigned char ak4114_init_txcsb[] = {
                0x41, 0x02, 0x2c, 0x00, 0x00
        };
-       struct ak4114 *ak;
        int err;
 
+       struct revo51_spec *spec;
+       spec = kzalloc(sizeof(*spec), GFP_KERNEL);
+       if (!spec)
+               return -ENOMEM;
+       ice->spec = spec;
+
        err = snd_ak4114_create(ice->card,
                                 ap192_ak4114_read,
                                 ap192_ak4114_write,
                                 ak4114_init_vals, ak4114_init_txcsb,
-                                ice, &ak);
+                                ice, &spec->ak4114);
        /* AK4114 in Revo cannot detect external rate correctly.
         * No reason to stop capture stream due to incorrect checks */
-       ak->check_flags = AK4114_CHECK_NO_RATE;
+       spec->ak4114->check_flags = AK4114_CHECK_NO_RATE;
 
        return 0; /* error ignored; it's no fatal error */
 }
@@ -562,6 +568,9 @@ static int revo_init(struct snd_ice1712 *ice)
                                               ice);
                if (err < 0)
                        return err;
+               err = ap192_ak4114_init(ice);
+               if (err < 0)
+                       return err;
                
                /* unmute all codecs */
                snd_ice1712_gpio_write_bits(ice, VT1724_REVO_MUTE,
@@ -575,7 +584,7 @@ static int revo_init(struct snd_ice1712 *ice)
 
 static int revo_add_controls(struct snd_ice1712 *ice)
 {
-       struct revo51_spec *spec;
+       struct revo51_spec *spec = ice->spec;
        int err;
 
        switch (ice->eeprom.subvendor) {
@@ -597,7 +606,9 @@ static int revo_add_controls(struct snd_ice1712 *ice)
                err = snd_ice1712_akm4xxx_build_controls(ice);
                if (err < 0)
                        return err;
-               err = ap192_ak4114_init(ice);
+               /* only capture SPDIF over AK4114 */
+               err = snd_ak4114_build(spec->ak4114, NULL,
+                  ice->pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream);
                if (err < 0)
                        return err;
                break;