1 files changed, 106 insertions, 161 deletions

diff --git a/drivers/sbus/char/bbc_i2c.c b/drivers/sbus/char/bbc_i2c.c
index ac8ef2ce07fb..af7f4af6c5fb 100644
--- a/drivers/sbus/char/bbc_i2c.c
+++ b/drivers/sbus/char/bbc_i2c.c
@@ -1,8 +1,7 @@
-/* $Id: bbc_i2c.c,v 1.2 2001/04/02 09:59:08 davem Exp $
- * bbc_i2c.c: I2C low-level driver for BBC device on UltraSPARC-III
+/* bbc_i2c.c: I2C low-level driver for BBC device on UltraSPARC-III
  *            platforms.
  *
- * Copyright (C) 2001 David S. Miller (davem@redhat.com)
+ * Copyright (C) 2001, 2008 David S. Miller (davem@davemloft.net)
  */
 
 #include <linux/module.h>
@@ -14,9 +13,8 @@
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
-#include <asm/oplib.h>
-#include <asm/ebus.h>
-#include <asm/spitfire.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
 #include <asm/bbc.h>
 #include <asm/io.h>
 
@@ -53,54 +51,12 @@
  * The second controller also connects to the smartcard reader, if present.
  */
 
-#define NUM_CHILDREN    8
-struct bbc_i2c_bus {
-        struct bbc_i2c_bus              *next;
-        int                             index;
-        spinlock_t                      lock;
-        void                            __iomem *i2c_bussel_reg;
-        void                            __iomem *i2c_control_regs;
-        unsigned char                   own, clock;
-
-        wait_queue_head_t               wq;
-        volatile int                    waiting;
-
-        struct linux_ebus_device        *bus_edev;
-        struct {
-                struct linux_ebus_child *device;
-                int                     client_claimed;
-        } devs[NUM_CHILDREN];
-};
-
-static struct bbc_i2c_bus *all_bbc_i2c;
-
-struct bbc_i2c_client {
-        struct bbc_i2c_bus      *bp;
-        struct linux_ebus_child *echild;
-        int                     bus;
-        int                     address;
-};
-
-static int find_device(struct bbc_i2c_bus *bp, struct linux_ebus_child *echild)
+static void set_device_claimage(struct bbc_i2c_bus *bp, struct of_device *op, int val)
 {
         int i;
 
         for (i = 0; i < NUM_CHILDREN; i++) {
-                if (bp->devs[i].device == echild) {
-                        if (bp->devs[i].client_claimed)
-                                return 0;
-                        return 1;
-                }
-        }
-        return 0;
-}
-
-static void set_device_claimage(struct bbc_i2c_bus *bp, struct linux_ebus_child *echild, int val)
-{
-        int i;
-
-        for (i = 0; i < NUM_CHILDREN; i++) {
-                if (bp->devs[i].device == echild) {
+                if (bp->devs[i].device == op) {
                         bp->devs[i].client_claimed = val;
                         return;
                 }
@@ -110,61 +66,47 @@ static void set_device_claimage(struct bbc_i2c_bus *bp, struct linux_ebus_child
 #define claim_device(BP,ECHILD)         set_device_claimage(BP,ECHILD,1)
 #define release_device(BP,ECHILD)       set_device_claimage(BP,ECHILD,0)
 
-static struct bbc_i2c_bus *find_bus_for_device(struct linux_ebus_child *echild)
+struct of_device *bbc_i2c_getdev(struct bbc_i2c_bus *bp, int index)
 {
-        struct bbc_i2c_bus *bp = all_bbc_i2c;
+        struct of_device *op = NULL;
+        int curidx = 0, i;
 
-        while (bp != NULL) {
-                if (find_device(bp, echild) != 0)
+        for (i = 0; i < NUM_CHILDREN; i++) {
+                if (!(op = bp->devs[i].device))
                         break;
-                bp = bp->next;
+                if (curidx == index)
+                        goto out;
+                op = NULL;
+                curidx++;
         }
 
-        return bp;
-}
-
-struct linux_ebus_child *bbc_i2c_getdev(int index)
-{
-        struct bbc_i2c_bus *bp = all_bbc_i2c;
-        struct linux_ebus_child *echild = NULL;
-        int curidx = 0;
-
-        while (bp != NULL) {
-                struct bbc_i2c_bus *next = bp->next;
-                int i;
-
-                for (i = 0; i < NUM_CHILDREN; i++) {
-                        if (!(echild = bp->devs[i].device))
-                                break;
-                        if (curidx == index)
-                                goto out;
-                        echild = NULL;
-                        curidx++;
-                }
-                bp = next;
-        }
 out:
         if (curidx == index)
-                return echild;
+                return op;
         return NULL;
 }
 
-struct bbc_i2c_client *bbc_i2c_attach(struct linux_ebus_child *echild)
+struct bbc_i2c_client *bbc_i2c_attach(struct bbc_i2c_bus *bp, struct of_device *op)
 {
-        struct bbc_i2c_bus *bp = find_bus_for_device(echild);
         struct bbc_i2c_client *client;
+        const u32 *reg;
 
-        if (!bp)
-                return NULL;
         client = kzalloc(sizeof(*client), GFP_KERNEL);
         if (!client)
                 return NULL;
         client->bp = bp;
-        client->echild = echild;
-        client->bus = echild->resource[0].start;
-        client->address = echild->resource[1].start;
+        client->op = op;
+
+        reg = of_get_property(op->node, "reg", NULL);
+        if (!reg) {
+                kfree(client);
+                return NULL;
+        }
 
-        claim_device(bp, echild);
+        client->bus = reg[0];
+        client->address = reg[1];
+
+        claim_device(bp, op);
 
         return client;
 }
@@ -172,9 +114,9 @@ struct bbc_i2c_client *bbc_i2c_attach(struct linux_ebus_child *echild)
 void bbc_i2c_detach(struct bbc_i2c_client *client)
 {
         struct bbc_i2c_bus *bp = client->bp;
-        struct linux_ebus_child *echild = client->echild;
+        struct of_device *op = client->op;
 
-        release_device(bp, echild);
+        release_device(bp, op);
         kfree(client);
 }
 
@@ -355,44 +297,43 @@ static void __init reset_one_i2c(struct bbc_i2c_bus *bp)
         writeb(I2C_PCF_IDLE, bp->i2c_control_regs + 0x0);
 }
 
-static int __init attach_one_i2c(struct linux_ebus_device *edev, int index)
+static struct bbc_i2c_bus * __init attach_one_i2c(struct of_device *op, int index)
 {
         struct bbc_i2c_bus *bp;
-        struct linux_ebus_child *echild;
+        struct device_node *dp;
         int entry;
 
         bp = kzalloc(sizeof(*bp), GFP_KERNEL);
         if (!bp)
-                return -ENOMEM;
+                return NULL;
 
-        bp->i2c_control_regs = ioremap(edev->resource[0].start, 0x2);
+        bp->i2c_control_regs = of_ioremap(&op->resource[0], 0, 0x2, "bbc_i2c_regs");
         if (!bp->i2c_control_regs)
                 goto fail;
 
-        if (edev->num_addrs == 2) {
-                bp->i2c_bussel_reg = ioremap(edev->resource[1].start, 0x1);
-                if (!bp->i2c_bussel_reg)
-                        goto fail;
-        }
+        bp->i2c_bussel_reg = of_ioremap(&op->resource[1], 0, 0x1, "bbc_i2c_bussel");
+        if (!bp->i2c_bussel_reg)
+                goto fail;
 
         bp->waiting = 0;
         init_waitqueue_head(&bp->wq);
-        if (request_irq(edev->irqs[0], bbc_i2c_interrupt,
+        if (request_irq(op->irqs[0], bbc_i2c_interrupt,
                         IRQF_SHARED, "bbc_i2c", bp))
                 goto fail;
 
         bp->index = index;
-        bp->bus_edev = edev;
+        bp->op = op;
 
         spin_lock_init(&bp->lock);
-        bp->next = all_bbc_i2c;
-        all_bbc_i2c = bp;
 
         entry = 0;
-        for (echild = edev->children;
-             echild && entry < 8;
-             echild = echild->next, entry++) {
-                bp->devs[entry].device = echild;
+        for (dp = op->node->child;
+             dp && entry < 8;
+             dp = dp->sibling, entry++) {
+                struct of_device *child_op;
+
+                child_op = of_find_device_by_node(dp);
+                bp->devs[entry].device = child_op;
                 bp->devs[entry].client_claimed = 0;
         }
 
@@ -406,86 +347,90 @@ static int __init attach_one_i2c(struct linux_ebus_device *edev, int index)
 
         reset_one_i2c(bp);
 
-        return 0;
+        return bp;
 
 fail:
         if (bp->i2c_bussel_reg)
-                iounmap(bp->i2c_bussel_reg);
+                of_iounmap(&op->resource[1], bp->i2c_bussel_reg, 1);
         if (bp->i2c_control_regs)
-                iounmap(bp->i2c_control_regs);
+                of_iounmap(&op->resource[0], bp->i2c_control_regs, 2);
         kfree(bp);
-        return -EINVAL;
-}
-
-static int __init bbc_present(void)
-{
-        struct linux_ebus *ebus = NULL;
-        struct linux_ebus_device *edev = NULL;
-
-        for_each_ebus(ebus) {
-                for_each_ebusdev(edev, ebus) {
-                        if (!strcmp(edev->prom_node->name, "bbc"))
-                                return 1;
-                }
-        }
-        return 0;
+        return NULL;
 }
 
-extern int bbc_envctrl_init(void);
-extern void bbc_envctrl_cleanup(void);
-static void bbc_i2c_cleanup(void);
+extern int bbc_envctrl_init(struct bbc_i2c_bus *bp);
+extern void bbc_envctrl_cleanup(struct bbc_i2c_bus *bp);
 
-static int __init bbc_i2c_init(void)
+static int __devinit bbc_i2c_probe(struct of_device *op,
+                                   const struct of_device_id *match)
 {
-        struct linux_ebus *ebus = NULL;
-        struct linux_ebus_device *edev = NULL;
+        struct bbc_i2c_bus *bp;
         int err, index = 0;
 
-        if ((tlb_type != cheetah && tlb_type != cheetah_plus) ||
-            !bbc_present())
-                return -ENODEV;
+        bp = attach_one_i2c(op, index);
+        if (!bp)
+                return -EINVAL;
 
-        for_each_ebus(ebus) {
-                for_each_ebusdev(edev, ebus) {
-                        if (!strcmp(edev->prom_node->name, "i2c")) {
-                                if (!attach_one_i2c(edev, index))
-                                        index++;
-                        }
-                }
+        err = bbc_envctrl_init(bp);
+        if (err) {
+                free_irq(op->irqs[0], bp);
+                if (bp->i2c_bussel_reg)
+                        of_iounmap(&op->resource[0], bp->i2c_bussel_reg, 1);
+                if (bp->i2c_control_regs)
+                        of_iounmap(&op->resource[1], bp->i2c_control_regs, 2);
+                kfree(bp);
+        } else {
+                dev_set_drvdata(&op->dev, bp);
         }
 
-        if (!index)
-                return -ENODEV;
-
-        err = bbc_envctrl_init();
-        if (err)
-                bbc_i2c_cleanup();
         return err;
 }
 
-static void bbc_i2c_cleanup(void)
+static int __devexit bbc_i2c_remove(struct of_device *op)
 {
-        struct bbc_i2c_bus *bp = all_bbc_i2c;
+        struct bbc_i2c_bus *bp = dev_get_drvdata(&op->dev);
+
+        bbc_envctrl_cleanup(bp);
+
+        free_irq(op->irqs[0], bp);
 
-        bbc_envctrl_cleanup();
+        if (bp->i2c_bussel_reg)
+                of_iounmap(&op->resource[0], bp->i2c_bussel_reg, 1);
+        if (bp->i2c_control_regs)
+                of_iounmap(&op->resource[1], bp->i2c_control_regs, 2);
 
-        while (bp != NULL) {
-                struct bbc_i2c_bus *next = bp->next;
+        kfree(bp);
 
-                free_irq(bp->bus_edev->irqs[0], bp);
+        return 0;
+}
 
-                if (bp->i2c_bussel_reg)
-                        iounmap(bp->i2c_bussel_reg);
-                if (bp->i2c_control_regs)
-                        iounmap(bp->i2c_control_regs);
+static struct of_device_id bbc_i2c_match[] = {
+        {
+                .name = "i2c",
+                .compatible = "SUNW,bbc-i2c",
+        },
+        {},
+};
+MODULE_DEVICE_TABLE(of, bbc_i2c_match);
 
-                kfree(bp);
+static struct of_platform_driver bbc_i2c_driver = {
+        .name           = "bbc_i2c",
+        .match_table    = bbc_i2c_match,
+        .probe          = bbc_i2c_probe,
+        .remove         = __devexit_p(bbc_i2c_remove),
+};
 
-                bp = next;
-        }
-        all_bbc_i2c = NULL;
+static int __init bbc_i2c_init(void)
+{
+        return of_register_driver(&bbc_i2c_driver, &of_bus_type);
+}
+
+static void __exit bbc_i2c_exit(void)
+{
+        of_unregister_driver(&bbc_i2c_driver);
 }
 
 module_init(bbc_i2c_init);
-module_exit(bbc_i2c_cleanup);
+module_exit(bbc_i2c_exit);
+
 MODULE_LICENSE("GPL");