5 files changed, 300 insertions, 304 deletions

diff --git a/drivers/char/tpm/tpm.c b/drivers/char/tpm/tpm.c
index 049d128ae7f0..303f15880466 100644
--- a/drivers/char/tpm/tpm.c
+++ b/drivers/char/tpm/tpm.c
@@ -64,7 +64,7 @@ static ssize_t tpm_transmit(struct tpm_chip *chip, const char *buf,
         if (count == 0)
                 return -ENODATA;
         if (count > bufsiz) {
-                dev_err(&chip->pci_dev->dev,
+                dev_err(chip->dev,
                         "invalid count value %x %zx \n", count, bufsiz);
                 return -E2BIG;
         }
@@ -72,21 +72,21 @@ static ssize_t tpm_transmit(struct tpm_chip *chip, const char *buf,
         down(&chip->tpm_mutex);
 
         if ((rc = chip->vendor->send(chip, (u8 *) buf, count)) < 0) {
-                dev_err(&chip->pci_dev->dev,
+                dev_err(chip->dev,
                         "tpm_transmit: tpm_send: error %zd\n", rc);
                 goto out;
         }
 
         stop = jiffies + 2 * 60 * HZ;
         do {
-                u8 status = inb(chip->vendor->base + 1);
+                u8 status = chip->vendor->status(chip);
                 if ((status & chip->vendor->req_complete_mask) ==
                     chip->vendor->req_complete_val) {
                         goto out_recv;
                 }
 
                 if ((status == chip->vendor->req_canceled)) {
-                        dev_err(&chip->pci_dev->dev, "Operation Canceled\n");
+                        dev_err(chip->dev, "Operation Canceled\n");
                         rc = -ECANCELED;
                         goto out;
                 }
@@ -97,14 +97,14 @@ static ssize_t tpm_transmit(struct tpm_chip *chip, const char *buf,
 
 
         chip->vendor->cancel(chip);
-        dev_err(&chip->pci_dev->dev, "Operation Timed out\n");
+        dev_err(chip->dev, "Operation Timed out\n");
         rc = -ETIME;
         goto out;
 
 out_recv:
         rc = chip->vendor->recv(chip, (u8 *) buf, bufsiz);
         if (rc < 0)
-                dev_err(&chip->pci_dev->dev,
+                dev_err(chip->dev,
                         "tpm_transmit: tpm_recv: error %zd\n", rc);
 out:
         up(&chip->tpm_mutex);
@@ -139,15 +139,14 @@ ssize_t tpm_show_pcrs(struct device *dev, struct device_attribute *attr,
         __be32 index;
         char *str = buf;
 
-        struct tpm_chip *chip =
-            pci_get_drvdata(to_pci_dev(dev));
+        struct tpm_chip *chip = dev_get_drvdata(dev);
         if (chip == NULL)
                 return -ENODEV;
 
         memcpy(data, cap_pcr, sizeof(cap_pcr));
         if ((len = tpm_transmit(chip, data, sizeof(data)))
             < CAP_PCR_RESULT_SIZE) {
-                dev_dbg(&chip->pci_dev->dev, "A TPM error (%d) occurred "
+                dev_dbg(chip->dev, "A TPM error (%d) occurred "
                                 "attempting to determine the number of PCRS\n",
                         be32_to_cpu(*((__be32 *) (data + 6))));
                 return 0;
@@ -161,9 +160,10 @@ ssize_t tpm_show_pcrs(struct device *dev, struct device_attribute *attr,
                 memcpy(data + 10, &index, 4);
                 if ((len = tpm_transmit(chip, data, sizeof(data)))
                     < READ_PCR_RESULT_SIZE){
-                        dev_dbg(&chip->pci_dev->dev, "A TPM error (%d) occurred"
+                        dev_dbg(chip->dev, "A TPM error (%d) occurred"
                                 " attempting to read PCR %d of %d\n",
-                                be32_to_cpu(*((__be32 *) (data + 6))), i, num_pcrs);
+                                be32_to_cpu(*((__be32 *) (data + 6))),
+                                i, num_pcrs);
                         goto out;
                 }
                 str += sprintf(str, "PCR-%02d: ", i);
@@ -191,21 +191,19 @@ ssize_t tpm_show_pubek(struct device *dev, struct device_attribute *attr,
         int i, rc;
         char *str = buf;
 
-        struct tpm_chip *chip =
-            pci_get_drvdata(to_pci_dev(dev));
+        struct tpm_chip *chip = dev_get_drvdata(dev);
         if (chip == NULL)
                 return -ENODEV;
 
-        data = kmalloc(READ_PUBEK_RESULT_SIZE, GFP_KERNEL);
+        data = kzalloc(READ_PUBEK_RESULT_SIZE, GFP_KERNEL);
         if (!data)
                 return -ENOMEM;
 
         memcpy(data, readpubek, sizeof(readpubek));
-        memset(data + sizeof(readpubek), 0, 20);        /* zero nonce */
 
         if ((len = tpm_transmit(chip, data, READ_PUBEK_RESULT_SIZE)) <
             READ_PUBEK_RESULT_SIZE) {
-                dev_dbg(&chip->pci_dev->dev, "A TPM error (%d) occurred "
+                dev_dbg(chip->dev, "A TPM error (%d) occurred "
                                 "attempting to read the PUBEK\n",
                             be32_to_cpu(*((__be32 *) (data + 6))));
                 rc = 0;
@@ -245,7 +243,6 @@ out:
         kfree(data);
         return rc;
 }
-
 EXPORT_SYMBOL_GPL(tpm_show_pubek);
 
 #define CAP_VER_RESULT_SIZE 18
@@ -274,8 +271,7 @@ ssize_t tpm_show_caps(struct device *dev, struct device_attribute *attr,
         ssize_t len;
         char *str = buf;
 
-        struct tpm_chip *chip =
-            pci_get_drvdata(to_pci_dev(dev));
+        struct tpm_chip *chip = dev_get_drvdata(dev);
         if (chip == NULL)
                 return -ENODEV;
 
@@ -315,7 +311,6 @@ ssize_t tpm_store_cancel(struct device *dev, struct device_attribute *attr,
 }
 EXPORT_SYMBOL_GPL(tpm_store_cancel);
 
-
 /*
  * Device file system interface to the TPM
  */
@@ -339,21 +334,20 @@ int tpm_open(struct inode *inode, struct file *file)
         }
 
         if (chip->num_opens) {
-                dev_dbg(&chip->pci_dev->dev,
-                        "Another process owns this TPM\n");
+                dev_dbg(chip->dev, "Another process owns this TPM\n");
                 rc = -EBUSY;
                 goto err_out;
         }
 
         chip->num_opens++;
-        pci_dev_get(chip->pci_dev);
+        get_device(chip->dev);
 
         spin_unlock(&driver_lock);
 
         chip->data_buffer = kmalloc(TPM_BUFSIZE * sizeof(u8), GFP_KERNEL);
         if (chip->data_buffer == NULL) {
                 chip->num_opens--;
-                pci_dev_put(chip->pci_dev);
+                put_device(chip->dev);
                 return -ENOMEM;
         }
 
@@ -366,7 +360,6 @@ err_out:
         spin_unlock(&driver_lock);
         return rc;
 }
-
 EXPORT_SYMBOL_GPL(tpm_open);
 
 int tpm_release(struct inode *inode, struct file *file)
@@ -378,15 +371,14 @@ int tpm_release(struct inode *inode, struct file *file)
         chip->num_opens--;
         del_singleshot_timer_sync(&chip->user_read_timer);
         atomic_set(&chip->data_pending, 0);
-        pci_dev_put(chip->pci_dev);
+        put_device(chip->dev);
         kfree(chip->data_buffer);
         spin_unlock(&driver_lock);
         return 0;
 }
-
 EXPORT_SYMBOL_GPL(tpm_release);
 
-ssize_t tpm_write(struct file * file, const char __user * buf,
+ssize_t tpm_write(struct file *file, const char __user *buf,
                   size_t size, loff_t * off)
 {
         struct tpm_chip *chip = file->private_data;
@@ -422,7 +414,7 @@ ssize_t tpm_write(struct file * file, const char __user * buf,
 
 EXPORT_SYMBOL_GPL(tpm_write);
 
-ssize_t tpm_read(struct file * file, char __user * buf,
+ssize_t tpm_read(struct file * file, char __user *buf,
                  size_t size, loff_t * off)
 {
         struct tpm_chip *chip = file->private_data;
@@ -444,15 +436,14 @@ ssize_t tpm_read(struct file * file, char __user * buf,
 
         return ret_size;
 }
-
 EXPORT_SYMBOL_GPL(tpm_read);
 
-void __devexit tpm_remove(struct pci_dev *pci_dev)
+void tpm_remove_hardware(struct device *dev)
 {
-        struct tpm_chip *chip = pci_get_drvdata(pci_dev);
+        struct tpm_chip *chip = dev_get_drvdata(dev);
 
         if (chip == NULL) {
-                dev_err(&pci_dev->dev, "No device data found\n");
+                dev_err(dev, "No device data found\n");
                 return;
         }
 
@@ -462,22 +453,20 @@ void __devexit tpm_remove(struct pci_dev *pci_dev)
 
         spin_unlock(&driver_lock);
 
-        pci_set_drvdata(pci_dev, NULL);
+        dev_set_drvdata(dev, NULL);
         misc_deregister(&chip->vendor->miscdev);
         kfree(chip->vendor->miscdev.name);
 
-        sysfs_remove_group(&pci_dev->dev.kobj, chip->vendor->attr_group);
+        sysfs_remove_group(&dev->kobj, chip->vendor->attr_group);
 
-        pci_disable_device(pci_dev);
-
-        dev_mask[chip->dev_num / TPM_NUM_MASK_ENTRIES ] &= !(1 << (chip->dev_num % TPM_NUM_MASK_ENTRIES));
+        dev_mask[chip->dev_num / TPM_NUM_MASK_ENTRIES ] &=
+                !(1 << (chip->dev_num % TPM_NUM_MASK_ENTRIES));
 
         kfree(chip);
 
-        pci_dev_put(pci_dev);
+        put_device(dev);
 }
-
-EXPORT_SYMBOL_GPL(tpm_remove);
+EXPORT_SYMBOL_GPL(tpm_remove_hardware);
 
 static u8 savestate[] = {
         0, 193,                 /* TPM_TAG_RQU_COMMAND */
@@ -489,32 +478,30 @@ static u8 savestate[] = {
  * We are about to suspend. Save the TPM state
  * so that it can be restored.
  */
-int tpm_pm_suspend(struct pci_dev *pci_dev, pm_message_t pm_state)
+int tpm_pm_suspend(struct device *dev, pm_message_t pm_state)
 {
-        struct tpm_chip *chip = pci_get_drvdata(pci_dev);
+        struct tpm_chip *chip = dev_get_drvdata(dev);
         if (chip == NULL)
                 return -ENODEV;
 
         tpm_transmit(chip, savestate, sizeof(savestate));
         return 0;
 }
-
 EXPORT_SYMBOL_GPL(tpm_pm_suspend);
 
 /*
  * Resume from a power safe. The BIOS already restored
  * the TPM state.
  */
-int tpm_pm_resume(struct pci_dev *pci_dev)
+int tpm_pm_resume(struct device *dev)
 {
-        struct tpm_chip *chip = pci_get_drvdata(pci_dev);
+        struct tpm_chip *chip = dev_get_drvdata(dev);
 
         if (chip == NULL)
                 return -ENODEV;
 
         return 0;
 }
-
 EXPORT_SYMBOL_GPL(tpm_pm_resume);
 
 /*
@@ -524,8 +511,7 @@ EXPORT_SYMBOL_GPL(tpm_pm_resume);
  * upon errant exit from this function specific probe function should call
  * pci_disable_device
  */
-int tpm_register_hardware(struct pci_dev *pci_dev,
-                          struct tpm_vendor_specific *entry)
+int tpm_register_hardware(struct device *dev, struct tpm_vendor_specific *entry)
 {
 #define DEVNAME_SIZE 7
 
@@ -534,12 +520,10 @@ int tpm_register_hardware(struct pci_dev *pci_dev,
         int i, j;
 
         /* Driver specific per-device data */
-        chip = kmalloc(sizeof(*chip), GFP_KERNEL);
+        chip = kzalloc(sizeof(*chip), GFP_KERNEL);
         if (chip == NULL)
                 return -ENOMEM;
 
-        memset(chip, 0, sizeof(struct tpm_chip));
-
         init_MUTEX(&chip->buffer_mutex);
         init_MUTEX(&chip->tpm_mutex);
         INIT_LIST_HEAD(&chip->list);
@@ -563,8 +547,7 @@ int tpm_register_hardware(struct pci_dev *pci_dev,
 
 dev_num_search_complete:
         if (chip->dev_num < 0) {
-                dev_err(&pci_dev->dev,
-                        "No available tpm device numbers\n");
+                dev_err(dev, "No available tpm device numbers\n");
                 kfree(chip);
                 return -ENODEV;
         } else if (chip->dev_num == 0)
@@ -576,15 +559,15 @@ dev_num_search_complete:
         scnprintf(devname, DEVNAME_SIZE, "%s%d", "tpm", chip->dev_num);
         chip->vendor->miscdev.name = devname;
 
-        chip->vendor->miscdev.dev = &(pci_dev->dev);
-        chip->pci_dev = pci_dev_get(pci_dev);
+        chip->vendor->miscdev.dev = dev;
+        chip->dev = get_device(dev);
 
         if (misc_register(&chip->vendor->miscdev)) {
-                dev_err(&chip->pci_dev->dev,
+                dev_err(chip->dev,
                         "unable to misc_register %s, minor %d\n",
                         chip->vendor->miscdev.name,
                         chip->vendor->miscdev.minor);
-                pci_dev_put(pci_dev);
+                put_device(dev);
                 kfree(chip);
                 dev_mask[i] &= !(1 << j);
                 return -ENODEV;
@@ -592,17 +575,16 @@ dev_num_search_complete:
 
         spin_lock(&driver_lock);
 
-        pci_set_drvdata(pci_dev, chip);
+        dev_set_drvdata(dev, chip);
 
         list_add(&chip->list, &tpm_chip_list);
 
         spin_unlock(&driver_lock);
 
-        sysfs_create_group(&pci_dev->dev.kobj, chip->vendor->attr_group);
+        sysfs_create_group(&dev->kobj, chip->vendor->attr_group);
 
         return 0;
 }
-
 EXPORT_SYMBOL_GPL(tpm_register_hardware);
 
 MODULE_AUTHOR("Leendert van Doorn (leendert@watson.ibm.com)");
diff --git a/drivers/char/tpm/tpm.h b/drivers/char/tpm/tpm.h
index 373b41f6b460..024814b50c3c 100644
--- a/drivers/char/tpm/tpm.h
+++ b/drivers/char/tpm/tpm.h
@@ -55,12 +55,13 @@ struct tpm_vendor_specific {
         int (*recv) (struct tpm_chip *, u8 *, size_t);
         int (*send) (struct tpm_chip *, u8 *, size_t);
         void (*cancel) (struct tpm_chip *);
+        u8 (*status) (struct tpm_chip *);
         struct miscdevice miscdev;
         struct attribute_group *attr_group;
 };
 
 struct tpm_chip {
-        struct pci_dev *pci_dev;        /* PCI device stuff */
+        struct device *dev;     /* Device stuff */
 
         int dev_num;            /* /dev/tpm# */
         int num_opens;          /* only one allowed */
@@ -91,13 +92,13 @@ static inline void tpm_write_index(int base, int index, int value)
         outb(value & 0xFF, base+1);
 }
 
-extern int tpm_register_hardware(struct pci_dev *,
+extern int tpm_register_hardware(struct device *,
                                  struct tpm_vendor_specific *);
 extern int tpm_open(struct inode *, struct file *);
 extern int tpm_release(struct inode *, struct file *);
 extern ssize_t tpm_write(struct file *, const char __user *, size_t,
                          loff_t *);
 extern ssize_t tpm_read(struct file *, char __user *, size_t, loff_t *);
-extern void __devexit tpm_remove(struct pci_dev *);
-extern int tpm_pm_suspend(struct pci_dev *, pm_message_t);
-extern int tpm_pm_resume(struct pci_dev *);
+extern void tpm_remove_hardware(struct device *);
+extern int tpm_pm_suspend(struct device *, pm_message_t);
+extern int tpm_pm_resume(struct device *);
diff --git a/drivers/char/tpm/tpm_atmel.c b/drivers/char/tpm/tpm_atmel.c
index c0d64914595f..8cb42e84723c 100644
--- a/drivers/char/tpm/tpm_atmel.c
+++ b/drivers/char/tpm/tpm_atmel.c
@@ -40,7 +40,7 @@ enum tpm_atmel_read_status {
         ATML_STATUS_READY = 0x08
 };
 
-static int tpm_atml_recv(struct tpm_chip *chip, u8 * buf, size_t count)
+static int tpm_atml_recv(struct tpm_chip *chip, u8 *buf, size_t count)
 {
         u8 status, *hdr = buf;
         u32 size;
@@ -54,7 +54,7 @@ static int tpm_atml_recv(struct tpm_chip *chip, u8 * buf, size_t count)
         for (i = 0; i < 6; i++) {
                 status = inb(chip->vendor->base + 1);
                 if ((status & ATML_STATUS_DATA_AVAIL) == 0) {
-                        dev_err(&chip->pci_dev->dev,
+                        dev_err(chip->dev,
                                 "error reading header\n");
                         return -EIO;
                 }
@@ -66,12 +66,12 @@ static int tpm_atml_recv(struct tpm_chip *chip, u8 * buf, size_t count)
         size = be32_to_cpu(*native_size);
 
         if (count < size) {
-                dev_err(&chip->pci_dev->dev,
+                dev_err(chip->dev,
                         "Recv size(%d) less than available space\n", size);
                 for (; i < size; i++) { /* clear the waiting data anyway */
                         status = inb(chip->vendor->base + 1);
                         if ((status & ATML_STATUS_DATA_AVAIL) == 0) {
-                                dev_err(&chip->pci_dev->dev,
+                                dev_err(chip->dev,
                                         "error reading data\n");
                                 return -EIO;
                         }
@@ -83,7 +83,7 @@ static int tpm_atml_recv(struct tpm_chip *chip, u8 * buf, size_t count)
         for (; i < size; i++) {
                 status = inb(chip->vendor->base + 1);
                 if ((status & ATML_STATUS_DATA_AVAIL) == 0) {
-                        dev_err(&chip->pci_dev->dev,
+                        dev_err(chip->dev,
                                 "error reading data\n");
                         return -EIO;
                 }
@@ -93,20 +93,20 @@ static int tpm_atml_recv(struct tpm_chip *chip, u8 * buf, size_t count)
         /* make sure data available is gone */
         status = inb(chip->vendor->base + 1);
         if (status & ATML_STATUS_DATA_AVAIL) {
-                dev_err(&chip->pci_dev->dev, "data available is stuck\n");
+                dev_err(chip->dev, "data available is stuck\n");
                 return -EIO;
         }
 
         return size;
 }
 
-static int tpm_atml_send(struct tpm_chip *chip, u8 * buf, size_t count)
+static int tpm_atml_send(struct tpm_chip *chip, u8 *buf, size_t count)
 {
         int i;
 
-        dev_dbg(&chip->pci_dev->dev, "tpm_atml_send: ");
+        dev_dbg(chip->dev, "tpm_atml_send:\n");
         for (i = 0; i < count; i++) {
-                dev_dbg(&chip->pci_dev->dev, "0x%x(%d) ", buf[i], buf[i]);
+                dev_dbg(chip->dev, "%d 0x%x(%d)\n",  i, buf[i], buf[i]);
                 outb(buf[i], chip->vendor->base);
         }
 
@@ -118,6 +118,11 @@ static void tpm_atml_cancel(struct tpm_chip *chip)
         outb(ATML_STATUS_ABORT, chip->vendor->base + 1);
 }
 
+static u8 tpm_atml_status(struct tpm_chip *chip)
+{
+        return inb(chip->vendor->base + 1);
+}
+
 static struct file_operations atmel_ops = {
         .owner = THIS_MODULE,
         .llseek = no_llseek,
@@ -137,7 +142,7 @@ static struct attribute* atmel_attrs[] = {
         &dev_attr_pcrs.attr,
         &dev_attr_caps.attr,
         &dev_attr_cancel.attr,
-        0,
+        NULL,
 };
 
 static struct attribute_group atmel_attr_grp = { .attrs = atmel_attrs };
@@ -146,6 +151,7 @@ static struct tpm_vendor_specific tpm_atmel = {
         .recv = tpm_atml_recv,
         .send = tpm_atml_send,
         .cancel = tpm_atml_cancel,
+        .status = tpm_atml_status,
         .req_complete_mask = ATML_STATUS_BUSY | ATML_STATUS_DATA_AVAIL,
         .req_complete_val = ATML_STATUS_DATA_AVAIL,
         .req_canceled = ATML_STATUS_READY,
@@ -153,86 +159,94 @@ static struct tpm_vendor_specific tpm_atmel = {
         .miscdev = { .fops = &atmel_ops, },
 };
 
-static int __devinit tpm_atml_init(struct pci_dev *pci_dev,
-                                   const struct pci_device_id *pci_id)
+static struct platform_device *pdev;
+
+static void __devexit tpm_atml_remove(struct device *dev)
+{
+        struct tpm_chip *chip = dev_get_drvdata(dev);
+        if (chip) {
+                release_region(chip->vendor->base, 2);
+                tpm_remove_hardware(chip->dev);
+        }
+}
+
+static struct device_driver atml_drv = {
+        .name = "tpm_atmel",
+        .bus = &platform_bus_type,
+        .owner = THIS_MODULE,
+        .suspend = tpm_pm_suspend,
+        .resume = tpm_pm_resume,
+};
+
+static int __init init_atmel(void)
 {
-        u8 version[4];
         int rc = 0;
         int lo, hi;
 
-        if (pci_enable_device(pci_dev))
-                return -EIO;
+        driver_register(&atml_drv);
 
         lo = tpm_read_index(TPM_ADDR, TPM_ATMEL_BASE_ADDR_LO);
         hi = tpm_read_index(TPM_ADDR, TPM_ATMEL_BASE_ADDR_HI);
 
         tpm_atmel.base = (hi<<8)|lo;
-        dev_dbg( &pci_dev->dev, "Operating with base: 0x%x\n", tpm_atmel.base);
 
         /* verify that it is an Atmel part */
         if (tpm_read_index(TPM_ADDR, 4) != 'A' || tpm_read_index(TPM_ADDR, 5) != 'T'
             || tpm_read_index(TPM_ADDR, 6) != 'M' || tpm_read_index(TPM_ADDR, 7) != 'L') {
-                rc = -ENODEV;
-                goto out_err;
+                return -ENODEV;
         }
 
-        /* query chip for its version number */
-        if ((version[0] = tpm_read_index(TPM_ADDR, 0x00)) != 0xFF) {
-                version[1] = tpm_read_index(TPM_ADDR, 0x01);
-                version[2] = tpm_read_index(TPM_ADDR, 0x02);
-                version[3] = tpm_read_index(TPM_ADDR, 0x03);
-        } else {
-                dev_info(&pci_dev->dev, "version query failed\n");
-                rc = -ENODEV;
-                goto out_err;
+        /* verify chip version number is 1.1 */
+        if (    (tpm_read_index(TPM_ADDR, 0x00) != 0x01) ||
+                (tpm_read_index(TPM_ADDR, 0x01) != 0x01 ))
+                return -ENODEV;
+
+        pdev = kzalloc(sizeof(struct platform_device), GFP_KERNEL);
+        if ( !pdev )
+                return -ENOMEM;
+
+        pdev->name = "tpm_atmel0";
+        pdev->id = -1;
+        pdev->num_resources = 0;
+        pdev->dev.release = tpm_atml_remove;
+        pdev->dev.driver = &atml_drv;
+
+        if ((rc = platform_device_register(pdev)) < 0) {
+                kfree(pdev);
+                pdev = NULL;
+                return rc;
         }
 
-        if ((rc = tpm_register_hardware(pci_dev, &tpm_atmel)) < 0)
-                goto out_err;
+        if (request_region(tpm_atmel.base, 2, "tpm_atmel0") == NULL ) {
+                platform_device_unregister(pdev);
+                kfree(pdev);
+                pdev = NULL;
+                return -EBUSY;
+        }
 
-        dev_info(&pci_dev->dev,
-                 "Atmel TPM version %d.%d.%d.%d\n", version[0], version[1],
-                 version[2], version[3]);
+        if ((rc = tpm_register_hardware(&pdev->dev, &tpm_atmel)) < 0) {
+                release_region(tpm_atmel.base, 2);
+                platform_device_unregister(pdev);
+                kfree(pdev);
+                pdev = NULL;
+                return rc;
+        }
 
+        dev_info(&pdev->dev, "Atmel TPM 1.1, Base Address: 0x%x\n",
+                        tpm_atmel.base);
         return 0;
-out_err:
-        pci_disable_device(pci_dev);
-        return rc;
-}
-
-static struct pci_device_id tpm_pci_tbl[] __devinitdata = {
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_12)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_12)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801EB_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_1)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_8111_LPC)},
-        {PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB6LPC)},
-        {0,}
-};
-
-MODULE_DEVICE_TABLE(pci, tpm_pci_tbl);
-
-static struct pci_driver atmel_pci_driver = {
-        .name = "tpm_atmel",
-        .id_table = tpm_pci_tbl,
-        .probe = tpm_atml_init,
-        .remove = __devexit_p(tpm_remove),
-        .suspend = tpm_pm_suspend,
-        .resume = tpm_pm_resume,
-};
-
-static int __init init_atmel(void)
-{
-        return pci_register_driver(&atmel_pci_driver);
 }
 
 static void __exit cleanup_atmel(void)
 {
-        pci_unregister_driver(&atmel_pci_driver);
+        if (pdev) {
+                tpm_atml_remove(&pdev->dev);
+                platform_device_unregister(pdev);
+                kfree(pdev);
+                pdev = NULL;
+        }
+
+        driver_unregister(&atml_drv);
 }
 
 module_init(init_atmel);
diff --git a/drivers/char/tpm/tpm_infineon.c b/drivers/char/tpm/tpm_infineon.c
index 939e51e119e6..8198dbb7370f 100644
--- a/drivers/char/tpm/tpm_infineon.c
+++ b/drivers/char/tpm/tpm_infineon.c
@@ -5,6 +5,7 @@
  * Specifications at www.trustedcomputinggroup.org
  *
  * Copyright (C) 2005, Marcel Selhorst <selhorst@crypto.rub.de>
+ * Sirrix AG - security technologies, http://www.sirrix.com and
  * Applied Data Security Group, Ruhr-University Bochum, Germany
  * Project-Homepage: http://www.prosec.rub.de/tpm
  *
@@ -29,9 +30,10 @@
 #define TPM_INFINEON_DEV_VEN_VALUE      0x15D1
 
 /* These values will be filled after PnP-call */
-static int TPM_INF_DATA = 0;
-static int TPM_INF_ADDR = 0;
-static int pnp_registered = 0;
+static int TPM_INF_DATA;
+static int TPM_INF_ADDR;
+static int TPM_INF_BASE;
+static int TPM_INF_PORT_LEN;
 
 /* TPM header definitions */
 enum infineon_tpm_header {
@@ -143,11 +145,9 @@ static int wait(struct tpm_chip *chip, int wait_for_bit)
         }
         if (i == TPM_MAX_TRIES) {       /* timeout occurs */
                 if (wait_for_bit == STAT_XFE)
-                        dev_err(&chip->pci_dev->dev,
-                                "Timeout in wait(STAT_XFE)\n");
+                        dev_err(chip->dev, "Timeout in wait(STAT_XFE)\n");
                 if (wait_for_bit == STAT_RDA)
-                        dev_err(&chip->pci_dev->dev,
-                                "Timeout in wait(STAT_RDA)\n");
+                        dev_err(chip->dev, "Timeout in wait(STAT_RDA)\n");
                 return -EIO;
         }
         return 0;
@@ -170,7 +170,7 @@ static void wait_and_send(struct tpm_chip *chip, u8 sendbyte)
 static void tpm_wtx(struct tpm_chip *chip)
 {
         number_of_wtx++;
-        dev_info(&chip->pci_dev->dev, "Granting WTX (%02d / %02d)\n",
+        dev_info(chip->dev, "Granting WTX (%02d / %02d)\n",
                  number_of_wtx, TPM_MAX_WTX_PACKAGES);
         wait_and_send(chip, TPM_VL_VER);
         wait_and_send(chip, TPM_CTRL_WTX);
@@ -181,7 +181,7 @@ static void tpm_wtx(struct tpm_chip *chip)
 
 static void tpm_wtx_abort(struct tpm_chip *chip)
 {
-        dev_info(&chip->pci_dev->dev, "Aborting WTX\n");
+        dev_info(chip->dev, "Aborting WTX\n");
         wait_and_send(chip, TPM_VL_VER);
         wait_and_send(chip, TPM_CTRL_WTX_ABORT);
         wait_and_send(chip, 0x00);
@@ -206,7 +206,7 @@ recv_begin:
         }
 
         if (buf[0] != TPM_VL_VER) {
-                dev_err(&chip->pci_dev->dev,
+                dev_err(chip->dev,
                         "Wrong transport protocol implementation!\n");
                 return -EIO;
         }
@@ -221,8 +221,7 @@ recv_begin:
                 }
 
                 if ((size == 0x6D00) && (buf[1] == 0x80)) {
-                        dev_err(&chip->pci_dev->dev,
-                                "Error handling on vendor layer!\n");
+                        dev_err(chip->dev, "Error handling on vendor layer!\n");
                         return -EIO;
                 }
 
@@ -234,7 +233,7 @@ recv_begin:
         }
 
         if (buf[1] == TPM_CTRL_WTX) {
-                dev_info(&chip->pci_dev->dev, "WTX-package received\n");
+                dev_info(chip->dev, "WTX-package received\n");
                 if (number_of_wtx < TPM_MAX_WTX_PACKAGES) {
                         tpm_wtx(chip);
                         goto recv_begin;
@@ -245,14 +244,14 @@ recv_begin:
         }
 
         if (buf[1] == TPM_CTRL_WTX_ABORT_ACK) {
-                dev_info(&chip->pci_dev->dev, "WTX-abort acknowledged\n");
+                dev_info(chip->dev, "WTX-abort acknowledged\n");
                 return size;
         }
 
         if (buf[1] == TPM_CTRL_ERROR) {
-                dev_err(&chip->pci_dev->dev, "ERROR-package received:\n");
+                dev_err(chip->dev, "ERROR-package received:\n");
                 if (buf[4] == TPM_INF_NAK)
-                        dev_err(&chip->pci_dev->dev,
+                        dev_err(chip->dev,
                                 "-> Negative acknowledgement"
                                 " - retransmit command!\n");
                 return -EIO;
@@ -271,7 +270,7 @@ static int tpm_inf_send(struct tpm_chip *chip, u8 * buf, size_t count)
 
         ret = empty_fifo(chip, 1);
         if (ret) {
-                dev_err(&chip->pci_dev->dev, "Timeout while clearing FIFO\n");
+                dev_err(chip->dev, "Timeout while clearing FIFO\n");
                 return -EIO;
         }
 
@@ -316,6 +315,11 @@ static void tpm_inf_cancel(struct tpm_chip *chip)
          */
 }
 
+static u8 tpm_inf_status(struct tpm_chip *chip)
+{
+        return inb(chip->vendor->base + STAT);
+}
+
 static DEVICE_ATTR(pubek, S_IRUGO, tpm_show_pubek, NULL);
 static DEVICE_ATTR(pcrs, S_IRUGO, tpm_show_pcrs, NULL);
 static DEVICE_ATTR(caps, S_IRUGO, tpm_show_caps, NULL);
@@ -344,6 +348,7 @@ static struct tpm_vendor_specific tpm_inf = {
         .recv = tpm_inf_recv,
         .send = tpm_inf_send,
         .cancel = tpm_inf_cancel,
+        .status = tpm_inf_status,
         .req_complete_mask = 0,
         .req_complete_val = 0,
         .attr_group = &inf_attr_grp,
@@ -356,30 +361,11 @@ static const struct pnp_device_id tpm_pnp_tbl[] = {
         {"IFX0102", 0},
         {"", 0}
 };
+
 MODULE_DEVICE_TABLE(pnp, tpm_pnp_tbl);
 
 static int __devinit tpm_inf_pnp_probe(struct pnp_dev *dev,
-                                        const struct pnp_device_id *dev_id)
-{
-        if (pnp_port_valid(dev, 0)) {
-                TPM_INF_ADDR = (pnp_port_start(dev, 0) & 0xff);
-                TPM_INF_DATA = ((TPM_INF_ADDR + 1) & 0xff);
-                tpm_inf.base = pnp_port_start(dev, 1);
-                dev_info(&dev->dev, "Found %s with ID %s\n",
-                dev->name, dev_id->id);
-                return 0;
-        }
-        return -ENODEV;
-}
-
-static struct pnp_driver tpm_inf_pnp = {
-        .name = "tpm_inf_pnp",
-        .id_table = tpm_pnp_tbl,
-        .probe = tpm_inf_pnp_probe,
-};
-
-static int __devinit tpm_inf_probe(struct pci_dev *pci_dev,
-                                   const struct pci_device_id *pci_id)
+                                       const struct pnp_device_id *dev_id)
 {
         int rc = 0;
         u8 iol, ioh;
@@ -388,30 +374,28 @@ static int __devinit tpm_inf_probe(struct pci_dev *pci_dev,
         int productid[2];
         char chipname[20];
 
-        rc = pci_enable_device(pci_dev);
-        if (rc)
-                return rc;
-
-        dev_info(&pci_dev->dev, "LPC-bus found at 0x%x\n", pci_id->device);
-
-        /* read IO-ports from PnP */
-        rc = pnp_register_driver(&tpm_inf_pnp);
-        if (rc < 0) {
-                dev_err(&pci_dev->dev,
-                        "Error %x from pnp_register_driver!\n",rc);
-                goto error2;
-        }
-        if (!rc) {
-                dev_info(&pci_dev->dev, "No Infineon TPM found!\n");
-                goto error;
+        /* read IO-ports through PnP */
+        if (pnp_port_valid(dev, 0) && pnp_port_valid(dev, 1) &&
+            !(pnp_port_flags(dev, 0) & IORESOURCE_DISABLED)) {
+                TPM_INF_ADDR = pnp_port_start(dev, 0);
+                TPM_INF_DATA = (TPM_INF_ADDR + 1);
+                TPM_INF_BASE = pnp_port_start(dev, 1);
+                TPM_INF_PORT_LEN = pnp_port_len(dev, 1);
+                if (!TPM_INF_PORT_LEN)
+                        return -EINVAL;
+                dev_info(&dev->dev, "Found %s with ID %s\n",
+                         dev->name, dev_id->id);
+                if (!((TPM_INF_BASE >> 8) & 0xff))
+                        return -EINVAL;
+                /* publish my base address and request region */
+                tpm_inf.base = TPM_INF_BASE;
+                if (request_region
+                    (tpm_inf.base, TPM_INF_PORT_LEN, "tpm_infineon0") == NULL) {
+                        release_region(tpm_inf.base, TPM_INF_PORT_LEN);
+                        return -EINVAL;
+                }
         } else {
-                pnp_registered = 1;
-        }
-
-        /* Make sure, we have received valid config ports */
-        if (!TPM_INF_ADDR) {
-                dev_err(&pci_dev->dev, "No valid IO-ports received!\n");
-                goto error;
+                return -EINVAL;
         }
 
         /* query chip for its vendor, its version number a.s.o. */
@@ -443,10 +427,6 @@ static int __devinit tpm_inf_probe(struct pci_dev *pci_dev,
 
         if ((vendorid[0] << 8 | vendorid[1]) == (TPM_INFINEON_DEV_VEN_VALUE)) {
 
-                if (tpm_inf.base == 0) {
-                        dev_err(&pci_dev->dev, "No IO-ports found!\n");
-                        goto error;
-                }
                 /* configure TPM with IO-ports */
                 outb(IOLIMH, TPM_INF_ADDR);
                 outb(((tpm_inf.base >> 8) & 0xff), TPM_INF_DATA);
@@ -460,10 +440,11 @@ static int __devinit tpm_inf_probe(struct pci_dev *pci_dev,
                 iol = inb(TPM_INF_DATA);
 
                 if ((ioh << 8 | iol) != tpm_inf.base) {
-                        dev_err(&pci_dev->dev,
+                        dev_err(&dev->dev,
                                 "Could not set IO-ports to %04x\n",
                                 tpm_inf.base);
-                        goto error;
+                        release_region(tpm_inf.base, TPM_INF_PORT_LEN);
+                        return -EIO;
                 }
 
                 /* activate register */
@@ -475,7 +456,7 @@ static int __devinit tpm_inf_probe(struct pci_dev *pci_dev,
                 outb(RESET_LP_IRQC_DISABLE, tpm_inf.base + CMD);
 
                 /* Finally, we're done, print some infos */
-                dev_info(&pci_dev->dev, "TPM found: "
+                dev_info(&dev->dev, "TPM found: "
                          "config base 0x%x, "
                          "io base 0x%x, "
                          "chip version %02x%02x, "
@@ -483,59 +464,53 @@ static int __devinit tpm_inf_probe(struct pci_dev *pci_dev,
                          "product id %02x%02x"
                          "%s\n",
                          TPM_INF_ADDR,
-                         tpm_inf.base,
+                         TPM_INF_BASE,
                          version[0], version[1],
                          vendorid[0], vendorid[1],
                          productid[0], productid[1], chipname);
 
-                rc = tpm_register_hardware(pci_dev, &tpm_inf);
-                if (rc < 0)
-                        goto error;
+                rc = tpm_register_hardware(&dev->dev, &tpm_inf);
+                if (rc < 0) {
+                        release_region(tpm_inf.base, TPM_INF_PORT_LEN);
+                        return -ENODEV;
+                }
                 return 0;
         } else {
-                dev_info(&pci_dev->dev, "No Infineon TPM found!\n");
-error:
-                pnp_unregister_driver(&tpm_inf_pnp);
-error2:
-                pci_disable_device(pci_dev);
-                pnp_registered = 0;
+                dev_info(&dev->dev, "No Infineon TPM found!\n");
                 return -ENODEV;
         }
 }
 
-static struct pci_device_id tpm_pci_tbl[] __devinitdata = {
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_12)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_12)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801EB_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_1)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_2)},
-        {0,}
-};
+static __devexit void tpm_inf_pnp_remove(struct pnp_dev *dev)
+{
+        struct tpm_chip *chip = pnp_get_drvdata(dev);
 
-MODULE_DEVICE_TABLE(pci, tpm_pci_tbl);
+        if (chip) {
+                release_region(chip->vendor->base, TPM_INF_PORT_LEN);
+                tpm_remove_hardware(chip->dev);
+        }
+}
 
-static struct pci_driver inf_pci_driver = {
-        .name = "tpm_inf",
-        .id_table = tpm_pci_tbl,
-        .probe = tpm_inf_probe,
-        .remove = __devexit_p(tpm_remove),
-        .suspend = tpm_pm_suspend,
-        .resume = tpm_pm_resume,
+static struct pnp_driver tpm_inf_pnp = {
+        .name = "tpm_inf_pnp",
+        .driver = {
+                .owner = THIS_MODULE,
+                .suspend = tpm_pm_suspend,
+                .resume = tpm_pm_resume,
+        },
+        .id_table = tpm_pnp_tbl,
+        .probe = tpm_inf_pnp_probe,
+        .remove = tpm_inf_pnp_remove,
 };
 
 static int __init init_inf(void)
 {
-        return pci_register_driver(&inf_pci_driver);
+        return pnp_register_driver(&tpm_inf_pnp);
 }
 
 static void __exit cleanup_inf(void)
 {
-        if (pnp_registered)
-                pnp_unregister_driver(&tpm_inf_pnp);
-        pci_unregister_driver(&inf_pci_driver);
+        pnp_unregister_driver(&tpm_inf_pnp);
 }
 
 module_init(init_inf);
@@ -543,5 +518,5 @@ module_exit(cleanup_inf);
 
 MODULE_AUTHOR("Marcel Selhorst <selhorst@crypto.rub.de>");
 MODULE_DESCRIPTION("Driver for Infineon TPM SLD 9630 TT 1.1 / SLB 9635 TT 1.2");
-MODULE_VERSION("1.5");
+MODULE_VERSION("1.6");
 MODULE_LICENSE("GPL");
diff --git a/drivers/char/tpm/tpm_nsc.c b/drivers/char/tpm/tpm_nsc.c
index b4127348c063..253871b5b1e2 100644
--- a/drivers/char/tpm/tpm_nsc.c
+++ b/drivers/char/tpm/tpm_nsc.c
@@ -111,7 +111,7 @@ static int nsc_wait_for_ready(struct tpm_chip *chip)
         }
         while (time_before(jiffies, stop));
 
-        dev_info(&chip->pci_dev->dev, "wait for ready failed\n");
+        dev_info(chip->dev, "wait for ready failed\n");
         return -EBUSY;
 }
 
@@ -127,12 +127,12 @@ static int tpm_nsc_recv(struct tpm_chip *chip, u8 * buf, size_t count)
                 return -EIO;
 
         if (wait_for_stat(chip, NSC_STATUS_F0, NSC_STATUS_F0, &data) < 0) {
-                dev_err(&chip->pci_dev->dev, "F0 timeout\n");
+                dev_err(chip->dev, "F0 timeout\n");
                 return -EIO;
         }
         if ((data =
              inb(chip->vendor->base + NSC_DATA)) != NSC_COMMAND_NORMAL) {
-                dev_err(&chip->pci_dev->dev, "not in normal mode (0x%x)\n",
+                dev_err(chip->dev, "not in normal mode (0x%x)\n",
                         data);
                 return -EIO;
         }
@@ -141,7 +141,7 @@ static int tpm_nsc_recv(struct tpm_chip *chip, u8 * buf, size_t count)
         for (p = buffer; p < &buffer[count]; p++) {
                 if (wait_for_stat
                     (chip, NSC_STATUS_OBF, NSC_STATUS_OBF, &data) < 0) {
-                        dev_err(&chip->pci_dev->dev,
+                        dev_err(chip->dev,
                                 "OBF timeout (while reading data)\n");
                         return -EIO;
                 }
@@ -152,11 +152,11 @@ static int tpm_nsc_recv(struct tpm_chip *chip, u8 * buf, size_t count)
 
         if ((data & NSC_STATUS_F0) == 0 &&
         (wait_for_stat(chip, NSC_STATUS_F0, NSC_STATUS_F0, &data) < 0)) {
-                dev_err(&chip->pci_dev->dev, "F0 not set\n");
+                dev_err(chip->dev, "F0 not set\n");
                 return -EIO;
         }
         if ((data = inb(chip->vendor->base + NSC_DATA)) != NSC_COMMAND_EOC) {
-                dev_err(&chip->pci_dev->dev,
+                dev_err(chip->dev,
                         "expected end of command(0x%x)\n", data);
                 return -EIO;
         }
@@ -187,19 +187,19 @@ static int tpm_nsc_send(struct tpm_chip *chip, u8 * buf, size_t count)
                 return -EIO;
 
         if (wait_for_stat(chip, NSC_STATUS_IBF, 0, &data) < 0) {
-                dev_err(&chip->pci_dev->dev, "IBF timeout\n");
+                dev_err(chip->dev, "IBF timeout\n");
                 return -EIO;
         }
 
         outb(NSC_COMMAND_NORMAL, chip->vendor->base + NSC_COMMAND);
         if (wait_for_stat(chip, NSC_STATUS_IBR, NSC_STATUS_IBR, &data) < 0) {
-                dev_err(&chip->pci_dev->dev, "IBR timeout\n");
+                dev_err(chip->dev, "IBR timeout\n");
                 return -EIO;
         }
 
         for (i = 0; i < count; i++) {
                 if (wait_for_stat(chip, NSC_STATUS_IBF, 0, &data) < 0) {
-                        dev_err(&chip->pci_dev->dev,
+                        dev_err(chip->dev,
                                 "IBF timeout (while writing data)\n");
                         return -EIO;
                 }
@@ -207,7 +207,7 @@ static int tpm_nsc_send(struct tpm_chip *chip, u8 * buf, size_t count)
         }
 
         if (wait_for_stat(chip, NSC_STATUS_IBF, 0, &data) < 0) {
-                dev_err(&chip->pci_dev->dev, "IBF timeout\n");
+                dev_err(chip->dev, "IBF timeout\n");
                 return -EIO;
         }
         outb(NSC_COMMAND_EOC, chip->vendor->base + NSC_COMMAND);
@@ -220,6 +220,11 @@ static void tpm_nsc_cancel(struct tpm_chip *chip)
         outb(NSC_COMMAND_CANCEL, chip->vendor->base + NSC_COMMAND);
 }
 
+static u8 tpm_nsc_status(struct tpm_chip *chip)
+{
+        return inb(chip->vendor->base + NSC_STATUS);
+}
+
 static struct file_operations nsc_ops = {
         .owner = THIS_MODULE,
         .llseek = no_llseek,
@@ -239,7 +244,7 @@ static struct attribute * nsc_attrs[] = {
         &dev_attr_pcrs.attr,
         &dev_attr_caps.attr,
         &dev_attr_cancel.attr,
-        0,
+        NULL,
 };
 
 static struct attribute_group nsc_attr_grp = { .attrs = nsc_attrs };
@@ -248,6 +253,7 @@ static struct tpm_vendor_specific tpm_nsc = {
         .recv = tpm_nsc_recv,
         .send = tpm_nsc_send,
         .cancel = tpm_nsc_cancel,
+        .status = tpm_nsc_status,
         .req_complete_mask = NSC_STATUS_OBF,
         .req_complete_val = NSC_STATUS_OBF,
         .req_canceled = NSC_STATUS_RDY,
@@ -255,16 +261,32 @@ static struct tpm_vendor_specific tpm_nsc = {
         .miscdev = { .fops = &nsc_ops, },
 };
 
-static int __devinit tpm_nsc_init(struct pci_dev *pci_dev,
-                                  const struct pci_device_id *pci_id)
+static struct platform_device *pdev = NULL;
+
+static void __devexit tpm_nsc_remove(struct device *dev)
+{
+        struct tpm_chip *chip = dev_get_drvdata(dev);
+        if ( chip ) {
+                release_region(chip->vendor->base, 2);
+                tpm_remove_hardware(chip->dev);
+        }
+}
+
+static struct device_driver nsc_drv = {
+        .name = "tpm_nsc",
+        .bus = &platform_bus_type,
+        .owner = THIS_MODULE,
+        .suspend = tpm_pm_suspend,
+        .resume = tpm_pm_resume,
+};
+
+static int __init init_nsc(void)
 {
         int rc = 0;
         int lo, hi;
         int nscAddrBase = TPM_ADDR;
 
-
-        if (pci_enable_device(pci_dev))
-                return -EIO;
+        driver_register(&nsc_drv);
 
         /* select PM channel 1 */
         tpm_write_index(nscAddrBase,NSC_LDN_INDEX, 0x12);
@@ -273,37 +295,71 @@ static int __devinit tpm_nsc_init(struct pci_dev *pci_dev,
         if (tpm_read_index(TPM_ADDR, NSC_SID_INDEX) != 0xEF) {
                 nscAddrBase = (tpm_read_index(TPM_SUPERIO_ADDR, 0x2C)<<8)|
                         (tpm_read_index(TPM_SUPERIO_ADDR, 0x2B)&0xFE);
-                if (tpm_read_index(nscAddrBase, NSC_SID_INDEX) != 0xF6) {
-                        rc = -ENODEV;
-                        goto out_err;
-                }
+                if (tpm_read_index(nscAddrBase, NSC_SID_INDEX) != 0xF6)
+                        return -ENODEV;
         }
 
         hi = tpm_read_index(nscAddrBase, TPM_NSC_BASE0_HI);
         lo = tpm_read_index(nscAddrBase, TPM_NSC_BASE0_LO);
         tpm_nsc.base = (hi<<8) | lo;
 
-        dev_dbg(&pci_dev->dev, "NSC TPM detected\n");
-        dev_dbg(&pci_dev->dev,
+        /* enable the DPM module */
+        tpm_write_index(nscAddrBase, NSC_LDC_INDEX, 0x01);
+
+        pdev = kmalloc(sizeof(struct platform_device), GFP_KERNEL);
+        if ( !pdev )
+                return -ENOMEM;
+
+        memset(pdev, 0, sizeof(struct platform_device));
+
+        pdev->name = "tpm_nscl0";
+        pdev->id = -1;
+        pdev->num_resources = 0;
+        pdev->dev.release = tpm_nsc_remove;
+        pdev->dev.driver = &nsc_drv;
+
+        if ((rc=platform_device_register(pdev)) < 0) {
+                kfree(pdev);
+                pdev = NULL;
+                return rc;
+        }
+
+        if (request_region(tpm_nsc.base, 2, "tpm_nsc0") == NULL ) {
+                platform_device_unregister(pdev);
+                kfree(pdev);
+                pdev = NULL;
+                return -EBUSY;
+        }
+
+        if ((rc = tpm_register_hardware(&pdev->dev, &tpm_nsc)) < 0) {
+                release_region(tpm_nsc.base, 2);
+                platform_device_unregister(pdev);
+                kfree(pdev);
+                pdev = NULL;
+                return rc;
+        }
+
+        dev_dbg(&pdev->dev, "NSC TPM detected\n");
+        dev_dbg(&pdev->dev,
                 "NSC LDN 0x%x, SID 0x%x, SRID 0x%x\n",
                 tpm_read_index(nscAddrBase,0x07), tpm_read_index(nscAddrBase,0x20),
                 tpm_read_index(nscAddrBase,0x27));
-        dev_dbg(&pci_dev->dev,
+        dev_dbg(&pdev->dev,
                 "NSC SIOCF1 0x%x SIOCF5 0x%x SIOCF6 0x%x SIOCF8 0x%x\n",
                 tpm_read_index(nscAddrBase,0x21), tpm_read_index(nscAddrBase,0x25),
                 tpm_read_index(nscAddrBase,0x26), tpm_read_index(nscAddrBase,0x28));
-        dev_dbg(&pci_dev->dev, "NSC IO Base0 0x%x\n",
+        dev_dbg(&pdev->dev, "NSC IO Base0 0x%x\n",
                 (tpm_read_index(nscAddrBase,0x60) << 8) | tpm_read_index(nscAddrBase,0x61));
-        dev_dbg(&pci_dev->dev, "NSC IO Base1 0x%x\n",
+        dev_dbg(&pdev->dev, "NSC IO Base1 0x%x\n",
                 (tpm_read_index(nscAddrBase,0x62) << 8) | tpm_read_index(nscAddrBase,0x63));
-        dev_dbg(&pci_dev->dev, "NSC Interrupt number and wakeup 0x%x\n",
+        dev_dbg(&pdev->dev, "NSC Interrupt number and wakeup 0x%x\n",
                 tpm_read_index(nscAddrBase,0x70));
-        dev_dbg(&pci_dev->dev, "NSC IRQ type select 0x%x\n",
+        dev_dbg(&pdev->dev, "NSC IRQ type select 0x%x\n",
                 tpm_read_index(nscAddrBase,0x71));
-        dev_dbg(&pci_dev->dev,
+        dev_dbg(&pdev->dev,
                 "NSC DMA channel select0 0x%x, select1 0x%x\n",
                 tpm_read_index(nscAddrBase,0x74), tpm_read_index(nscAddrBase,0x75));
-        dev_dbg(&pci_dev->dev,
+        dev_dbg(&pdev->dev,
                 "NSC Config "
                 "0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
                 tpm_read_index(nscAddrBase,0xF0), tpm_read_index(nscAddrBase,0xF1),
@@ -312,55 +368,23 @@ static int __devinit tpm_nsc_init(struct pci_dev *pci_dev,
                 tpm_read_index(nscAddrBase,0xF6), tpm_read_index(nscAddrBase,0xF7),
                 tpm_read_index(nscAddrBase,0xF8), tpm_read_index(nscAddrBase,0xF9));
 
-        dev_info(&pci_dev->dev,
+        dev_info(&pdev->dev,
                  "NSC TPM revision %d\n",
                  tpm_read_index(nscAddrBase, 0x27) & 0x1F);
 
-        /* enable the DPM module */
-        tpm_write_index(nscAddrBase, NSC_LDC_INDEX, 0x01);
-
-        if ((rc = tpm_register_hardware(pci_dev, &tpm_nsc)) < 0)
-                goto out_err;
-
         return 0;
-
-out_err:
-        pci_disable_device(pci_dev);
-        return rc;
-}
-
-static struct pci_device_id tpm_pci_tbl[] __devinitdata = {
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_12)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_12)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801EB_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_1)},
-        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_0)},
-        {PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_8111_LPC)},
-        {0,}
-};
-
-MODULE_DEVICE_TABLE(pci, tpm_pci_tbl);
-
-static struct pci_driver nsc_pci_driver = {
-        .name = "tpm_nsc",
-        .id_table = tpm_pci_tbl,
-        .probe = tpm_nsc_init,
-        .remove = __devexit_p(tpm_remove),
-        .suspend = tpm_pm_suspend,
-        .resume = tpm_pm_resume,
-};
-
-static int __init init_nsc(void)
-{
-        return pci_register_driver(&nsc_pci_driver);
 }
 
 static void __exit cleanup_nsc(void)
 {
-        pci_unregister_driver(&nsc_pci_driver);
+        if (pdev) {
+                tpm_nsc_remove(&pdev->dev);
+                platform_device_unregister(pdev);
+                kfree(pdev);
+                pdev = NULL;
+        }
+
+        driver_unregister(&nsc_drv);
 }
 
 module_init(init_nsc);