20 files changed, 268 insertions, 135 deletions

diff --git a/drivers/crypto/padlock-aes.c b/drivers/crypto/padlock-aes.c
index ed708b4427b0..71407c578afe 100644
--- a/drivers/crypto/padlock-aes.c
+++ b/drivers/crypto/padlock-aes.c
@@ -49,6 +49,7 @@
 #include <linux/errno.h>
 #include <linux/crypto.h>
 #include <linux/interrupt.h>
+#include <linux/kernel.h>
 #include <asm/byteorder.h>
 #include "padlock.h"
 
@@ -59,8 +60,12 @@
 #define AES_EXTENDED_KEY_SIZE_B (AES_EXTENDED_KEY_SIZE * sizeof(uint32_t))
 
 struct aes_ctx {
-        uint32_t e_data[AES_EXTENDED_KEY_SIZE+4];
-        uint32_t d_data[AES_EXTENDED_KEY_SIZE+4];
+        uint32_t e_data[AES_EXTENDED_KEY_SIZE];
+        uint32_t d_data[AES_EXTENDED_KEY_SIZE];
+        struct {
+                struct cword encrypt;
+                struct cword decrypt;
+        } cword;
         uint32_t *E;
         uint32_t *D;
         int key_length;
@@ -280,10 +285,15 @@ aes_hw_extkey_available(uint8_t key_len)
         return 0;
 }
 
+static inline struct aes_ctx *aes_ctx(void *ctx)
+{
+        return (struct aes_ctx *)ALIGN((unsigned long)ctx, PADLOCK_ALIGNMENT);
+}
+
 static int
 aes_set_key(void *ctx_arg, const uint8_t *in_key, unsigned int key_len, uint32_t *flags)
 {
-        struct aes_ctx *ctx = ctx_arg;
+        struct aes_ctx *ctx = aes_ctx(ctx_arg);
         uint32_t i, t, u, v, w;
         uint32_t P[AES_EXTENDED_KEY_SIZE];
         uint32_t rounds;
@@ -295,25 +305,36 @@ aes_set_key(void *ctx_arg, const uint8_t *in_key, unsigned int key_len, uint32_t
 
         ctx->key_length = key_len;
 
+        /*
+         * If the hardware is capable of generating the extended key
+         * itself we must supply the plain key for both encryption
+         * and decryption.
+         */
         ctx->E = ctx->e_data;
-        ctx->D = ctx->d_data;
-
-        /* Ensure 16-Bytes alignmentation of keys for VIA PadLock. */
-        if ((int)(ctx->e_data) & 0x0F)
-                ctx->E += 4 - (((int)(ctx->e_data) & 0x0F) / sizeof (ctx->e_data[0]));
-
-        if ((int)(ctx->d_data) & 0x0F)
-                ctx->D += 4 - (((int)(ctx->d_data) & 0x0F) / sizeof (ctx->d_data[0]));
+        ctx->D = ctx->e_data;
 
         E_KEY[0] = uint32_t_in (in_key);
         E_KEY[1] = uint32_t_in (in_key + 4);
         E_KEY[2] = uint32_t_in (in_key + 8);
         E_KEY[3] = uint32_t_in (in_key + 12);
 
+        /* Prepare control words. */
+        memset(&ctx->cword, 0, sizeof(ctx->cword));
+
+        ctx->cword.decrypt.encdec = 1;
+        ctx->cword.encrypt.rounds = 10 + (key_len - 16) / 4;
+        ctx->cword.decrypt.rounds = ctx->cword.encrypt.rounds;
+        ctx->cword.encrypt.ksize = (key_len - 16) / 8;
+        ctx->cword.decrypt.ksize = ctx->cword.encrypt.ksize;
+
         /* Don't generate extended keys if the hardware can do it. */
         if (aes_hw_extkey_available(key_len))
                 return 0;
 
+        ctx->D = ctx->d_data;
+        ctx->cword.encrypt.keygen = 1;
+        ctx->cword.decrypt.keygen = 1;
+
         switch (key_len) {
         case 16:
                 t = E_KEY[3];
@@ -369,10 +390,9 @@ aes_set_key(void *ctx_arg, const uint8_t *in_key, unsigned int key_len, uint32_t
 
 /* ====== Encryption/decryption routines ====== */
 
-/* This is the real call to PadLock. */
-static inline void
-padlock_xcrypt_ecb(uint8_t *input, uint8_t *output, uint8_t *key,
-                   void *control_word, uint32_t count)
+/* These are the real call to PadLock. */
+static inline void padlock_xcrypt_ecb(const u8 *input, u8 *output, void *key,
+                                      void *control_word, u32 count)
 {
         asm volatile ("pushfl; popfl");         /* enforce key reload. */
         asm volatile (".byte 0xf3,0x0f,0xa7,0xc8"       /* rep xcryptecb */
@@ -380,60 +400,70 @@ padlock_xcrypt_ecb(uint8_t *input, uint8_t *output, uint8_t *key,
                       : "d"(control_word), "b"(key), "c"(count));
 }
 
-static void
-aes_padlock(void *ctx_arg, uint8_t *out_arg, const uint8_t *in_arg, int encdec)
+static inline u8 *padlock_xcrypt_cbc(const u8 *input, u8 *output, void *key,
+                                     u8 *iv, void *control_word, u32 count)
 {
-        /* Don't blindly modify this structure - the items must 
-           fit on 16-Bytes boundaries! */
-        struct padlock_xcrypt_data {
-                uint8_t buf[AES_BLOCK_SIZE];
-                union cword cword;
-        };
-
-        struct aes_ctx *ctx = ctx_arg;
-        char bigbuf[sizeof(struct padlock_xcrypt_data) + 16];
-        struct padlock_xcrypt_data *data;
-        void *key;
-
-        /* Place 'data' at the first 16-Bytes aligned address in 'bigbuf'. */
-        if (((long)bigbuf) & 0x0F)
-                data = (void*)(bigbuf + 16 - ((long)bigbuf & 0x0F));
-        else
-                data = (void*)bigbuf;
-
-        /* Prepare Control word. */
-        memset (data, 0, sizeof(struct padlock_xcrypt_data));
-        data->cword.b.encdec = !encdec; /* in the rest of cryptoapi ENC=1/DEC=0 */
-        data->cword.b.rounds = 10 + (ctx->key_length - 16) / 4;
-        data->cword.b.ksize = (ctx->key_length - 16) / 8;
-
-        /* Is the hardware capable to generate the extended key? */
-        if (!aes_hw_extkey_available(ctx->key_length))
-                data->cword.b.keygen = 1;
-
-        /* ctx->E starts with a plain key - if the hardware is capable
-           to generate the extended key itself we must supply
-           the plain key for both Encryption and Decryption. */
-        if (encdec == CRYPTO_DIR_ENCRYPT || data->cword.b.keygen == 0)
-                key = ctx->E;
-        else
-                key = ctx->D;
-        
-        memcpy(data->buf, in_arg, AES_BLOCK_SIZE);
-        padlock_xcrypt_ecb(data->buf, data->buf, key, &data->cword, 1);
-        memcpy(out_arg, data->buf, AES_BLOCK_SIZE);
+        /* Enforce key reload. */
+        asm volatile ("pushfl; popfl");
+        /* rep xcryptcbc */
+        asm volatile (".byte 0xf3,0x0f,0xa7,0xd0"
+                      : "+S" (input), "+D" (output), "+a" (iv)
+                      : "d" (control_word), "b" (key), "c" (count));
+        return iv;
 }
 
 static void
 aes_encrypt(void *ctx_arg, uint8_t *out, const uint8_t *in)
 {
-        aes_padlock(ctx_arg, out, in, CRYPTO_DIR_ENCRYPT);
+        struct aes_ctx *ctx = aes_ctx(ctx_arg);
+        padlock_xcrypt_ecb(in, out, ctx->E, &ctx->cword.encrypt, 1);
 }
 
 static void
 aes_decrypt(void *ctx_arg, uint8_t *out, const uint8_t *in)
 {
-        aes_padlock(ctx_arg, out, in, CRYPTO_DIR_DECRYPT);
+        struct aes_ctx *ctx = aes_ctx(ctx_arg);
+        padlock_xcrypt_ecb(in, out, ctx->D, &ctx->cword.decrypt, 1);
+}
+
+static unsigned int aes_encrypt_ecb(const struct cipher_desc *desc, u8 *out,
+                                    const u8 *in, unsigned int nbytes)
+{
+        struct aes_ctx *ctx = aes_ctx(crypto_tfm_ctx(desc->tfm));
+        padlock_xcrypt_ecb(in, out, ctx->E, &ctx->cword.encrypt,
+                           nbytes / AES_BLOCK_SIZE);
+        return nbytes & ~(AES_BLOCK_SIZE - 1);
+}
+
+static unsigned int aes_decrypt_ecb(const struct cipher_desc *desc, u8 *out,
+                                    const u8 *in, unsigned int nbytes)
+{
+        struct aes_ctx *ctx = aes_ctx(crypto_tfm_ctx(desc->tfm));
+        padlock_xcrypt_ecb(in, out, ctx->D, &ctx->cword.decrypt,
+                           nbytes / AES_BLOCK_SIZE);
+        return nbytes & ~(AES_BLOCK_SIZE - 1);
+}
+
+static unsigned int aes_encrypt_cbc(const struct cipher_desc *desc, u8 *out,
+                                    const u8 *in, unsigned int nbytes)
+{
+        struct aes_ctx *ctx = aes_ctx(crypto_tfm_ctx(desc->tfm));
+        u8 *iv;
+
+        iv = padlock_xcrypt_cbc(in, out, ctx->E, desc->info,
+                                &ctx->cword.encrypt, nbytes / AES_BLOCK_SIZE);
+        memcpy(desc->info, iv, AES_BLOCK_SIZE);
+
+        return nbytes & ~(AES_BLOCK_SIZE - 1);
+}
+
+static unsigned int aes_decrypt_cbc(const struct cipher_desc *desc, u8 *out,
+                                    const u8 *in, unsigned int nbytes)
+{
+        struct aes_ctx *ctx = aes_ctx(crypto_tfm_ctx(desc->tfm));
+        padlock_xcrypt_cbc(in, out, ctx->D, desc->info, &ctx->cword.decrypt,
+                           nbytes / AES_BLOCK_SIZE);
+        return nbytes & ~(AES_BLOCK_SIZE - 1);
 }
 
 static struct crypto_alg aes_alg = {
@@ -441,6 +471,7 @@ static struct crypto_alg aes_alg = {
         .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
         .cra_blocksize          =       AES_BLOCK_SIZE,
         .cra_ctxsize            =       sizeof(struct aes_ctx),
+        .cra_alignmask          =       PADLOCK_ALIGNMENT - 1,
         .cra_module             =       THIS_MODULE,
         .cra_list               =       LIST_HEAD_INIT(aes_alg.cra_list),
         .cra_u                  =       {
@@ -449,7 +480,11 @@ static struct crypto_alg aes_alg = {
                         .cia_max_keysize        =       AES_MAX_KEY_SIZE,
                         .cia_setkey             =       aes_set_key,
                         .cia_encrypt            =       aes_encrypt,
-                        .cia_decrypt            =       aes_decrypt
+                        .cia_decrypt            =       aes_decrypt,
+                        .cia_encrypt_ecb        =       aes_encrypt_ecb,
+                        .cia_decrypt_ecb        =       aes_decrypt_ecb,
+                        .cia_encrypt_cbc        =       aes_encrypt_cbc,
+                        .cia_decrypt_cbc        =       aes_decrypt_cbc,
                 }
         }
 };
diff --git a/drivers/crypto/padlock.h b/drivers/crypto/padlock.h
index 7a500605e449..3cf2b7a12348 100644
--- a/drivers/crypto/padlock.h
+++ b/drivers/crypto/padlock.h
@@ -13,18 +13,18 @@
 #ifndef _CRYPTO_PADLOCK_H
 #define _CRYPTO_PADLOCK_H
 
+#define PADLOCK_ALIGNMENT 16
+
 /* Control word. */
-union cword {
-        uint32_t cword[4];
-        struct {
-                int rounds:4;
-                int algo:3;
-                int keygen:1;
-                int interm:1;
-                int encdec:1;
-                int ksize:2;
-        } b;
-};
+struct cword {
+        int __attribute__ ((__packed__))
+                rounds:4,
+                algo:3,
+                keygen:1,
+                interm:1,
+                encdec:1,
+                ksize:2;
+} __attribute__ ((__aligned__(PADLOCK_ALIGNMENT)));
 
 #define PFX     "padlock: "
 
diff --git a/drivers/i2c/busses/i2c-keywest.c b/drivers/i2c/busses/i2c-keywest.c
index 363e545fc01f..94ae808314f7 100644
--- a/drivers/i2c/busses/i2c-keywest.c
+++ b/drivers/i2c/busses/i2c-keywest.c
@@ -698,7 +698,7 @@ dispose_iface(struct device *dev)
 }
 
 static int
-create_iface_macio(struct macio_dev* dev, const struct of_match *match)
+create_iface_macio(struct macio_dev* dev, const struct of_device_id *match)
 {
         return create_iface(dev->ofdev.node, &dev->ofdev.dev);
 }
@@ -710,7 +710,7 @@ dispose_iface_macio(struct macio_dev* dev)
 }
 
 static int
-create_iface_of_platform(struct of_device* dev, const struct of_match *match)
+create_iface_of_platform(struct of_device* dev, const struct of_device_id *match)
 {
         return create_iface(dev->node, &dev->dev);
 }
@@ -721,10 +721,9 @@ dispose_iface_of_platform(struct of_device* dev)
         return dispose_iface(&dev->dev);
 }
 
-static struct of_match i2c_keywest_match[] = 
+static struct of_device_id i2c_keywest_match[] = 
 {
         {
-        .name           = OF_ANY_MATCH,
         .type           = "i2c",
         .compatible     = "keywest"
         },
diff --git a/drivers/ide/ppc/pmac.c b/drivers/ide/ppc/pmac.c
index 818380b5fd27..be0fcc8f4b15 100644
--- a/drivers/ide/ppc/pmac.c
+++ b/drivers/ide/ppc/pmac.c
@@ -1419,7 +1419,7 @@ pmac_ide_setup_device(pmac_ide_hwif_t *pmif, ide_hwif_t *hwif)
  * Attach to a macio probed interface
  */
 static int __devinit
-pmac_ide_macio_attach(struct macio_dev *mdev, const struct of_match *match)
+pmac_ide_macio_attach(struct macio_dev *mdev, const struct of_device_id *match)
 {
         void __iomem *base;
         unsigned long regbase;
@@ -1637,27 +1637,19 @@ pmac_ide_pci_resume(struct pci_dev *pdev)
         return rc;
 }
 
-static struct of_match pmac_ide_macio_match[] = 
+static struct of_device_id pmac_ide_macio_match[] = 
 {
         {
         .name           = "IDE",
-        .type           = OF_ANY_MATCH,
-        .compatible     = OF_ANY_MATCH
         },
         {
         .name           = "ATA",
-        .type           = OF_ANY_MATCH,
-        .compatible     = OF_ANY_MATCH
         },
         {
-        .name           = OF_ANY_MATCH,
         .type           = "ide",
-        .compatible     = OF_ANY_MATCH
         },
         {
-        .name           = OF_ANY_MATCH,
         .type           = "ata",
-        .compatible     = OF_ANY_MATCH
         },
         {},
 };
diff --git a/drivers/ieee1394/ieee1394_core.h b/drivers/ieee1394/ieee1394_core.h
index 73bd8efd2b6c..0b31429d0a68 100644
--- a/drivers/ieee1394/ieee1394_core.h
+++ b/drivers/ieee1394/ieee1394_core.h
@@ -38,8 +38,8 @@ struct hpsb_packet {
 
         /* These are core internal. */
         signed char tlabel;
-        char ack_code;
-        char tcode;
+        signed char ack_code;
+        unsigned char tcode;
 
         unsigned expect_response:1;
         unsigned no_waiter:1;
diff --git a/drivers/macintosh/Makefile b/drivers/macintosh/Makefile
index f5ae171dbfef..236291bd48a4 100644
--- a/drivers/macintosh/Makefile
+++ b/drivers/macintosh/Makefile
@@ -4,7 +4,7 @@
 
 # Each configuration option enables a list of files.
 
-obj-$(CONFIG_PPC_PMAC)          += macio_asic.o
+obj-$(CONFIG_PPC_PMAC)          += macio_asic.o macio_sysfs.o
 
 obj-$(CONFIG_PMAC_MEDIABAY)     += mediabay.o
 obj-$(CONFIG_MAC_EMUMOUSEBTN)   += mac_hid.o
diff --git a/drivers/macintosh/macio_asic.c b/drivers/macintosh/macio_asic.c
index d0bda7e3e6aa..1ee003346923 100644
--- a/drivers/macintosh/macio_asic.c
+++ b/drivers/macintosh/macio_asic.c
@@ -33,7 +33,7 @@ static int macio_bus_match(struct device *dev, struct device_driver *drv)
 {
         struct macio_dev * macio_dev = to_macio_device(dev);
         struct macio_driver * macio_drv = to_macio_driver(drv);
-        const struct of_match * matches = macio_drv->match_table;
+        const struct of_device_id * matches = macio_drv->match_table;
 
         if (!matches) 
                 return 0;
@@ -66,7 +66,7 @@ static int macio_device_probe(struct device *dev)
         int error = -ENODEV;
         struct macio_driver *drv;
         struct macio_dev *macio_dev;
-        const struct of_match *match;
+        const struct of_device_id *match;
 
         drv = to_macio_driver(dev->driver);
         macio_dev = to_macio_device(dev);
@@ -126,11 +126,85 @@ static int macio_device_resume(struct device * dev)
         return 0;
 }
 
+static int macio_hotplug (struct device *dev, char **envp, int num_envp,
+                          char *buffer, int buffer_size)
+{
+        struct macio_dev * macio_dev;
+        struct of_device * of;
+        char *scratch, *compat;
+        int i = 0;
+        int length = 0;
+        int cplen, seen = 0;
+
+        if (!dev)
+                return -ENODEV;
+
+        macio_dev = to_macio_device(dev);
+        if (!macio_dev)
+                return -ENODEV;
+
+        of = &macio_dev->ofdev;
+        scratch = buffer;
+
+        /* stuff we want to pass to /sbin/hotplug */
+        envp[i++] = scratch;
+        length += scnprintf (scratch, buffer_size - length, "OF_NAME=%s",
+                             of->node->name);
+        if ((buffer_size - length <= 0) || (i >= num_envp))
+                return -ENOMEM;
+        ++length;
+        scratch += length;
+
+        envp[i++] = scratch;
+        length += scnprintf (scratch, buffer_size - length, "OF_TYPE=%s",
+                             of->node->type);
+        if ((buffer_size - length <= 0) || (i >= num_envp))
+                return -ENOMEM;
+        ++length;
+        scratch += length;
+
+        /* Since the compatible field can contain pretty much anything
+         * it's not really legal to split it out with commas. We split it
+         * up using a number of environment variables instead. */
+
+        compat = (char *) get_property(of->node, "compatible", &cplen);
+        while (compat && cplen > 0) {
+                int l;
+                envp[i++] = scratch;
+                length += scnprintf (scratch, buffer_size - length,
+                                     "OF_COMPATIBLE_%d=%s", seen, compat);
+                if ((buffer_size - length <= 0) || (i >= num_envp))
+                        return -ENOMEM;
+                length++;
+                scratch += length;
+                l = strlen (compat) + 1;
+                compat += l;
+                cplen -= l;
+                seen++;
+        }
+
+        envp[i++] = scratch;
+        length += scnprintf (scratch, buffer_size - length,
+                             "OF_COMPATIBLE_N=%d", seen);
+        if ((buffer_size - length <= 0) || (i >= num_envp))
+                return -ENOMEM;
+        ++length;
+        scratch += length;
+
+        envp[i] = NULL;
+
+        return 0;
+}
+
+extern struct device_attribute macio_dev_attrs[];
+
 struct bus_type macio_bus_type = {
        .name    = "macio",
        .match   = macio_bus_match,
+       .hotplug = macio_hotplug,
        .suspend = macio_device_suspend,
        .resume  = macio_device_resume,
+       .dev_attrs = macio_dev_attrs,
 };
 
 static int __init macio_bus_driver_init(void)
diff --git a/drivers/macintosh/macio_sysfs.c b/drivers/macintosh/macio_sysfs.c
new file mode 100644
index 000000000000..97d22bb4516a
--- /dev/null
+++ b/drivers/macintosh/macio_sysfs.c
@@ -0,0 +1,50 @@
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/stat.h>
+#include <asm/macio.h>
+
+
+#define macio_config_of_attr(field, format_string)                      \
+static ssize_t                                                          \
+field##_show (struct device *dev, struct device_attribute *attr,        \
+              char *buf)                                                \
+{                                                                       \
+        struct macio_dev *mdev = to_macio_device (dev);                 \
+        return sprintf (buf, format_string, mdev->ofdev.node->field);   \
+}
+
+static ssize_t
+compatible_show (struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct of_device *of;
+        char *compat;
+        int cplen;
+        int length = 0;
+
+        of = &to_macio_device (dev)->ofdev;
+        compat = (char *) get_property(of->node, "compatible", &cplen);
+        if (!compat) {
+                *buf = '\0';
+                return 0;
+        }
+        while (cplen > 0) {
+                int l;
+                length += sprintf (buf, "%s\n", compat);
+                buf += length;
+                l = strlen (compat) + 1;
+                compat += l;
+                cplen -= l;
+        }
+
+        return length;
+}
+
+macio_config_of_attr (name, "%s\n");
+macio_config_of_attr (type, "%s\n");
+
+struct device_attribute macio_dev_attrs[] = {
+        __ATTR_RO(name),
+        __ATTR_RO(type),
+        __ATTR_RO(compatible),
+        __ATTR_NULL
+};
diff --git a/drivers/macintosh/mediabay.c b/drivers/macintosh/mediabay.c
index 4be709e13eec..7c16c25fc5d4 100644
--- a/drivers/macintosh/mediabay.c
+++ b/drivers/macintosh/mediabay.c
@@ -642,7 +642,7 @@ static int __pmac media_bay_task(void *x)
         }
 }
 
-static int __devinit media_bay_attach(struct macio_dev *mdev, const struct of_match *match)
+static int __devinit media_bay_attach(struct macio_dev *mdev, const struct of_device_id *match)
 {
         struct media_bay_info* bay;
         u32 __iomem *regbase;
@@ -797,23 +797,20 @@ static struct mb_ops keylargo_mb_ops __pmacdata = {
  * Therefore we do it all by polling the media bay once each tick.
  */
 
-static struct of_match media_bay_match[] =
+static struct of_device_id media_bay_match[] =
 {
         {
         .name           = "media-bay",
-        .type           = OF_ANY_MATCH,
         .compatible     = "keylargo-media-bay",
         .data           = &keylargo_mb_ops,
         },
         {
         .name           = "media-bay",
-        .type           = OF_ANY_MATCH,
         .compatible     = "heathrow-media-bay",
         .data           = &heathrow_mb_ops,
         },
         {
         .name           = "media-bay",
-        .type           = OF_ANY_MATCH,
         .compatible     = "ohare-media-bay",
         .data           = &ohare_mb_ops,
         },
diff --git a/drivers/macintosh/therm_pm72.c b/drivers/macintosh/therm_pm72.c
index feb4e2413858..703e31973314 100644
--- a/drivers/macintosh/therm_pm72.c
+++ b/drivers/macintosh/therm_pm72.c
@@ -120,6 +120,7 @@
 #include <asm/system.h>
 #include <asm/sections.h>
 #include <asm/of_device.h>
+#include <asm/macio.h>
 
 #include "therm_pm72.h"
 
@@ -1986,7 +1987,7 @@ static void fcu_lookup_fans(struct device_node *fcu_node)
         }
 }
 
-static int fcu_of_probe(struct of_device* dev, const struct of_match *match)
+static int fcu_of_probe(struct of_device* dev, const struct of_device_id *match)
 {
         int rc;
 
@@ -2009,12 +2010,10 @@ static int fcu_of_remove(struct of_device* dev)
         return 0;
 }
 
-static struct of_match fcu_of_match[] = 
+static struct of_device_id fcu_match[] = 
 {
         {
-        .name           = OF_ANY_MATCH,
         .type           = "fcu",
-        .compatible     = OF_ANY_MATCH
         },
         {},
 };
@@ -2022,7 +2021,7 @@ static struct of_match fcu_of_match[] =
 static struct of_platform_driver fcu_of_platform_driver = 
 {
         .name           = "temperature",
-        .match_table    = fcu_of_match,
+        .match_table    = fcu_match,
         .probe          = fcu_of_probe,
         .remove         = fcu_of_remove
 };
diff --git a/drivers/macintosh/therm_windtunnel.c b/drivers/macintosh/therm_windtunnel.c
index 61400f04015e..cbb72eb0426d 100644
--- a/drivers/macintosh/therm_windtunnel.c
+++ b/drivers/macintosh/therm_windtunnel.c
@@ -43,6 +43,7 @@
 #include <asm/system.h>
 #include <asm/sections.h>
 #include <asm/of_device.h>
+#include <asm/macio.h>
 
 #define LOG_TEMP                0                       /* continously log temperature */
 
@@ -450,7 +451,7 @@ do_probe( struct i2c_adapter *adapter, int addr, int kind )
 /************************************************************************/
 
 static int
-therm_of_probe( struct of_device *dev, const struct of_match *match )
+therm_of_probe( struct of_device *dev, const struct of_device_id *match )
 {
         return i2c_add_driver( &g4fan_driver );
 }
@@ -461,9 +462,8 @@ therm_of_remove( struct of_device *dev )
         return i2c_del_driver( &g4fan_driver );
 }
 
-static struct of_match therm_of_match[] = {{
+static struct of_device_id therm_of_match[] = {{
         .name           = "fan",
-        .type           = OF_ANY_MATCH,
         .compatible     = "adm1030"
     }, {}
 };
diff --git a/drivers/media/dvb/frontends/tda80xx.c b/drivers/media/dvb/frontends/tda80xx.c
index 032d348dafb7..88e125079ca1 100644
--- a/drivers/media/dvb/frontends/tda80xx.c
+++ b/drivers/media/dvb/frontends/tda80xx.c
@@ -27,7 +27,6 @@
 #include <linux/spinlock.h>
 #include <linux/threads.h>
 #include <linux/interrupt.h>
-#include <linux/irq.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/slab.h>
diff --git a/drivers/net/bmac.c b/drivers/net/bmac.c
index 00e5257b176f..8dc657fc8afb 100644
--- a/drivers/net/bmac.c
+++ b/drivers/net/bmac.c
@@ -1261,7 +1261,7 @@ static void bmac_reset_and_enable(struct net_device *dev)
         spin_unlock_irqrestore(&bp->lock, flags);
 }
 
-static int __devinit bmac_probe(struct macio_dev *mdev, const struct of_match *match)
+static int __devinit bmac_probe(struct macio_dev *mdev, const struct of_device_id *match)
 {
         int j, rev, ret;
         struct bmac_data *bp;
@@ -1645,16 +1645,13 @@ static int __devexit bmac_remove(struct macio_dev *mdev)
         return 0;
 }
 
-static struct of_match bmac_match[] = 
+static struct of_device_id bmac_match[] = 
 {
         {
         .name           = "bmac",
-        .type           = OF_ANY_MATCH,
-        .compatible     = OF_ANY_MATCH,
         .data           = (void *)0,
         },
         {
-        .name           = OF_ANY_MATCH,
         .type           = "network",
         .compatible     = "bmac+",
         .data           = (void *)1,
diff --git a/drivers/net/mace.c b/drivers/net/mace.c
index 6ed2d7dbd44c..81d0a26e4f41 100644
--- a/drivers/net/mace.c
+++ b/drivers/net/mace.c
@@ -109,7 +109,7 @@ bitrev(int b)
 }
 
 
-static int __devinit mace_probe(struct macio_dev *mdev, const struct of_match *match)
+static int __devinit mace_probe(struct macio_dev *mdev, const struct of_device_id *match)
 {
         struct device_node *mace = macio_get_of_node(mdev);
         struct net_device *dev;
@@ -1009,12 +1009,10 @@ static irqreturn_t mace_rxdma_intr(int irq, void *dev_id, struct pt_regs *regs)
     return IRQ_HANDLED;
 }
 
-static struct of_match mace_match[] = 
+static struct of_device_id mace_match[] = 
 {
         {
         .name           = "mace",
-        .type           = OF_ANY_MATCH,
-        .compatible     = OF_ANY_MATCH
         },
         {},
 };
diff --git a/drivers/net/wireless/airport.c b/drivers/net/wireless/airport.c
index b4f4bd7956a2..9d496703c465 100644
--- a/drivers/net/wireless/airport.c
+++ b/drivers/net/wireless/airport.c
@@ -184,7 +184,7 @@ static int airport_hard_reset(struct orinoco_private *priv)
 }
 
 static int
-airport_attach(struct macio_dev *mdev, const struct of_match *match)
+airport_attach(struct macio_dev *mdev, const struct of_device_id *match)
 {
         struct orinoco_private *priv;
         struct net_device *dev;
@@ -266,16 +266,16 @@ MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");
 MODULE_DESCRIPTION("Driver for the Apple Airport wireless card.");
 MODULE_LICENSE("Dual MPL/GPL");
 
-static struct of_match airport_match[] = 
+static struct of_device_id airport_match[] = 
 {
         {
         .name           = "radio",
-        .type           = OF_ANY_MATCH,
-        .compatible     = OF_ANY_MATCH
         },
         {},
 };
 
+MODULE_DEVICE_TABLE (of, airport_match);
+
 static struct macio_driver airport_driver = 
 {
         .name           = DRIVER_NAME,
diff --git a/drivers/pci/setup-bus.c b/drivers/pci/setup-bus.c
index c1bdfb424658..9fe48f712be9 100644
--- a/drivers/pci/setup-bus.c
+++ b/drivers/pci/setup-bus.c
@@ -74,6 +74,7 @@ pbus_assign_resources_sorted(struct pci_bus *bus)
                 idx = res - &list->dev->resource[0];
                 if (pci_assign_resource(list->dev, idx)) {
                         res->start = 0;
+                        res->end = 0;
                         res->flags = 0;
                 }
                 tmp = list;
diff --git a/drivers/scsi/mac53c94.c b/drivers/scsi/mac53c94.c
index edd47d1f0b17..932dcf0366eb 100644
--- a/drivers/scsi/mac53c94.c
+++ b/drivers/scsi/mac53c94.c
@@ -424,7 +424,7 @@ static struct scsi_host_template mac53c94_template = {
         .use_clustering = DISABLE_CLUSTERING,
 };
 
-static int mac53c94_probe(struct macio_dev *mdev, const struct of_match *match)
+static int mac53c94_probe(struct macio_dev *mdev, const struct of_device_id *match)
 {
         struct device_node *node = macio_get_of_node(mdev);
         struct pci_dev *pdev = macio_get_pci_dev(mdev);
@@ -544,15 +544,14 @@ static int mac53c94_remove(struct macio_dev *mdev)
 }
 
 
-static struct of_match mac53c94_match[] = 
+static struct of_device_id mac53c94_match[] = 
 {
         {
         .name           = "53c94",
-        .type           = OF_ANY_MATCH,
-        .compatible     = OF_ANY_MATCH
         },
         {},
 };
+MODULE_DEVICE_TABLE (of, mac53c94_match);
 
 static struct macio_driver mac53c94_driver = 
 {
diff --git a/drivers/scsi/mesh.c b/drivers/scsi/mesh.c
index b05737ae5eff..ff1933298da6 100644
--- a/drivers/scsi/mesh.c
+++ b/drivers/scsi/mesh.c
@@ -1847,7 +1847,7 @@ static struct scsi_host_template mesh_template = {
         .use_clustering                 = DISABLE_CLUSTERING,
 };
 
-static int mesh_probe(struct macio_dev *mdev, const struct of_match *match)
+static int mesh_probe(struct macio_dev *mdev, const struct of_device_id *match)
 {
         struct device_node *mesh = macio_get_of_node(mdev);
         struct pci_dev* pdev = macio_get_pci_dev(mdev);
@@ -2012,20 +2012,18 @@ static int mesh_remove(struct macio_dev *mdev)
 }
 
 
-static struct of_match mesh_match[] = 
+static struct of_device_id mesh_match[] = 
 {
         {
         .name           = "mesh",
-        .type           = OF_ANY_MATCH,
-        .compatible     = OF_ANY_MATCH
         },
         {
-        .name           = OF_ANY_MATCH,
         .type           = "scsi",
         .compatible     = "chrp,mesh0"
         },
         {},
 };
+MODULE_DEVICE_TABLE (of, mesh_match);
 
 static struct macio_driver mesh_driver = 
 {
diff --git a/drivers/serial/pmac_zilog.c b/drivers/serial/pmac_zilog.c
index 1c9f71617123..7db2f37532cf 100644
--- a/drivers/serial/pmac_zilog.c
+++ b/drivers/serial/pmac_zilog.c
@@ -1545,7 +1545,7 @@ static void pmz_dispose_port(struct uart_pmac_port *uap)
 /*
  * Called upon match with an escc node in the devive-tree.
  */
-static int pmz_attach(struct macio_dev *mdev, const struct of_match *match)
+static int pmz_attach(struct macio_dev *mdev, const struct of_device_id *match)
 {
         int i;
         
@@ -1850,20 +1850,17 @@ err_out:
         return rc;
 }
 
-static struct of_match pmz_match[] = 
+static struct of_device_id pmz_match[] = 
 {
         {
         .name           = "ch-a",
-        .type           = OF_ANY_MATCH,
-        .compatible     = OF_ANY_MATCH
         },
         {
         .name           = "ch-b",
-        .type           = OF_ANY_MATCH,
-        .compatible     = OF_ANY_MATCH
         },
         {},
 };
+MODULE_DEVICE_TABLE (of, pmz_match);
 
 static struct macio_driver pmz_driver = 
 {
diff --git a/drivers/video/platinumfb.c b/drivers/video/platinumfb.c
index 3dd1de1539d2..b00887e9851c 100644
--- a/drivers/video/platinumfb.c
+++ b/drivers/video/platinumfb.c
@@ -523,7 +523,7 @@ int __init platinumfb_setup(char *options)
 #define invalidate_cache(addr)
 #endif
 
-static int __devinit platinumfb_probe(struct of_device* odev, const struct of_match *match)
+static int __devinit platinumfb_probe(struct of_device* odev, const struct of_device_id *match)
 {
         struct device_node      *dp = odev->node;
         struct fb_info          *info;
@@ -647,12 +647,10 @@ static int __devexit platinumfb_remove(struct of_device* odev)
         return 0;
 }
 
-static struct of_match platinumfb_match[] = 
+static struct of_device_id platinumfb_match[] = 
 {
         {
         .name           = "platinum",
-        .type           = OF_ANY_MATCH,
-        .compatible     = OF_ANY_MATCH,
         },
         {},
 };