can: sja1000_isa: convert to platform driver to support x86_64 systems

This driver is currently not supported on x86_64 systems because the
"isa_driver" interface is used (CONFIG_ISA=y). To overcome this
limitation, the driver is converted to a platform driver, similar to
the serial 8250 driver.

Signed-off-by: Wolfgang Grandegger <wg@grandegger.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

2 files changed, 65 insertions, 30 deletions

diff --git a/drivers/net/can/sja1000/Kconfig b/drivers/net/can/sja1000/Kconfig
index fe9e64d476eb..36e9d594069d 100644
--- a/drivers/net/can/sja1000/Kconfig
+++ b/drivers/net/can/sja1000/Kconfig
@@ -6,7 +6,6 @@ if CAN_SJA1000
 
 config CAN_SJA1000_ISA
         tristate "ISA Bus based legacy SJA1000 driver"
-        depends on ISA
         ---help---
           This driver adds legacy support for SJA1000 chips connected to
           the ISA bus using I/O port, memory mapped or indirect access.
diff --git a/drivers/net/can/sja1000/sja1000_isa.c b/drivers/net/can/sja1000/sja1000_isa.c
index f0840d55ab72..90c5c2dfd2fd 100644
--- a/drivers/net/can/sja1000/sja1000_isa.c
+++ b/drivers/net/can/sja1000/sja1000_isa.c
@@ -17,7 +17,7 @@
 
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <linux/isa.h>
+#include <linux/platform_device.h>
 #include <linux/interrupt.h>
 #include <linux/netdevice.h>
 #include <linux/delay.h>
@@ -75,6 +75,8 @@ MODULE_PARM_DESC(ocr, "Output control register "
 #define SJA1000_IOSIZE          0x20
 #define SJA1000_IOSIZE_INDIRECT 0x02
 
+static struct platform_device *sja1000_isa_devs[MAXDEV];
+
 static u8 sja1000_isa_mem_read_reg(const struct sja1000_priv *priv, int reg)
 {
         return readb(priv->reg_base + reg);
@@ -115,26 +117,18 @@ static void sja1000_isa_port_write_reg_indirect(const struct sja1000_priv *priv,
         outb(val, base + 1);
 }
 
-static int __devinit sja1000_isa_match(struct device *pdev, unsigned int idx)
-{
-        if (port[idx] || mem[idx]) {
-                if (irq[idx])
-                        return 1;
-        } else if (idx)
-                return 0;
-
-        dev_err(pdev, "insufficient parameters supplied\n");
-        return 0;
-}
-
-static int __devinit sja1000_isa_probe(struct device *pdev, unsigned int idx)
+static int __devinit sja1000_isa_probe(struct platform_device *pdev)
 {
         struct net_device *dev;
         struct sja1000_priv *priv;
         void __iomem *base = NULL;
         int iosize = SJA1000_IOSIZE;
+        int idx = pdev->id;
         int err;
 
+        dev_dbg(&pdev->dev, "probing idx=%d: port=%#lx, mem=%#lx, irq=%d\n",
+                idx, port[idx], mem[idx], irq[idx]);
+
         if (mem[idx]) {
                 if (!request_mem_region(mem[idx], iosize, DRV_NAME)) {
                         err = -EBUSY;
@@ -203,17 +197,17 @@ static int __devinit sja1000_isa_probe(struct device *pdev, unsigned int idx)
         else
                 priv->cdr = CDR_DEFAULT;
 
-        dev_set_drvdata(pdev, dev);
-        SET_NETDEV_DEV(dev, pdev);
+        dev_set_drvdata(&pdev->dev, dev);
+        SET_NETDEV_DEV(dev, &pdev->dev);
 
         err = register_sja1000dev(dev);
         if (err) {
-                dev_err(pdev, "registering %s failed (err=%d)\n",
+                dev_err(&pdev->dev, "registering %s failed (err=%d)\n",
                         DRV_NAME, err);
                 goto exit_unmap;
         }
 
-        dev_info(pdev, "%s device registered (reg_base=0x%p, irq=%d)\n",
+        dev_info(&pdev->dev, "%s device registered (reg_base=0x%p, irq=%d)\n",
                  DRV_NAME, priv->reg_base, dev->irq);
         return 0;
 
@@ -229,13 +223,14 @@ static int __devinit sja1000_isa_probe(struct device *pdev, unsigned int idx)
         return err;
 }
 
-static int __devexit sja1000_isa_remove(struct device *pdev, unsigned int idx)
+static int __devexit sja1000_isa_remove(struct platform_device *pdev)
 {
-        struct net_device *dev = dev_get_drvdata(pdev);
+        struct net_device *dev = dev_get_drvdata(&pdev->dev);
         struct sja1000_priv *priv = netdev_priv(dev);
+        int idx = pdev->id;
 
         unregister_sja1000dev(dev);
-        dev_set_drvdata(pdev, NULL);
+        dev_set_drvdata(&pdev->dev, NULL);
 
         if (mem[idx]) {
                 iounmap(priv->reg_base);
@@ -251,29 +246,70 @@ static int __devexit sja1000_isa_remove(struct device *pdev, unsigned int idx)
         return 0;
 }
 
-static struct isa_driver sja1000_isa_driver = {
-        .match = sja1000_isa_match,
+static struct platform_driver sja1000_isa_driver = {
         .probe = sja1000_isa_probe,
         .remove = __devexit_p(sja1000_isa_remove),
         .driver = {
                 .name = DRV_NAME,
+                .owner = THIS_MODULE,
         },
 };
 
 static int __init sja1000_isa_init(void)
 {
-        int err = isa_register_driver(&sja1000_isa_driver, MAXDEV);
+        int idx, err;
+
+        for (idx = 0; idx < MAXDEV; idx++) {
+                if ((port[idx] || mem[idx]) && irq[idx]) {
+                        sja1000_isa_devs[idx] =
+                                platform_device_alloc(DRV_NAME, idx);
+                        if (!sja1000_isa_devs[idx]) {
+                                err = -ENOMEM;
+                                goto exit_free_devices;
+                        }
+                        err = platform_device_add(sja1000_isa_devs[idx]);
+                        if (err) {
+                                platform_device_put(sja1000_isa_devs[idx]);
+                                goto exit_free_devices;
+                        }
+                        pr_debug("%s: platform device %d: port=%#lx, mem=%#lx, "
+                                 "irq=%d\n",
+                                 DRV_NAME, idx, port[idx], mem[idx], irq[idx]);
+                } else if (idx == 0 || port[idx] || mem[idx]) {
+                                pr_err("%s: insufficient parameters supplied\n",
+                                       DRV_NAME);
+                                err = -EINVAL;
+                                goto exit_free_devices;
+                }
+        }
+
+        err = platform_driver_register(&sja1000_isa_driver);
+        if (err)
+                goto exit_free_devices;
+
+        pr_info("Legacy %s driver for max. %d devices registered\n",
+                DRV_NAME, MAXDEV);
+
+        return 0;
+
+exit_free_devices:
+        while (--idx >= 0) {
+                if (sja1000_isa_devs[idx])
+                        platform_device_unregister(sja1000_isa_devs[idx]);
+        }
 
-        if (!err)
-                printk(KERN_INFO
-                       "Legacy %s driver for max. %d devices registered\n",
-                       DRV_NAME, MAXDEV);
         return err;
 }
 
 static void __exit sja1000_isa_exit(void)
 {
-        isa_unregister_driver(&sja1000_isa_driver);
+        int idx;
+
+        platform_driver_unregister(&sja1000_isa_driver);
+        for (idx = 0; idx < MAXDEV; idx++) {
+                if (sja1000_isa_devs[idx])
+                        platform_device_unregister(sja1000_isa_devs[idx]);
+        }
 }
 
 module_init(sja1000_isa_init);