static int of_dev_phandle_match(struct device *dev, void *data)
 {
        phandle *ph = data;
-       return to_of_device(dev)->node->linux_phandle == *ph;
+       return to_of_device(dev)->node->phandle == *ph;
 }
 
 struct of_device *of_find_device_by_phandle(phandle ph)
 
 
        read_lock(&devtree_lock);
        for (np = allnodes; np != NULL; np = np->allnext)
-               if (np->linux_phandle == handle)
+               if (np->phandle == handle)
                        break;
        of_node_get(np);
        read_unlock(&devtree_lock);
 
 static int of_dev_phandle_match(struct device *dev, void *data)
 {
        phandle *ph = data;
-       return to_of_device(dev)->node->linux_phandle == *ph;
+       return to_of_device(dev)->node->phandle == *ph;
 }
 
 struct of_device *of_find_device_by_phandle(phandle ph)
 
 
        read_lock(&devtree_lock);
        for (np = allnodes; np != 0; np = np->allnext)
-               if (np->linux_phandle == handle)
+               if (np->phandle == handle)
                        break;
        of_node_get(np);
        read_unlock(&devtree_lock);
        if (machine_is(powermac))
                return -ENODEV;
 
-       /* fix up new node's linux_phandle field */
+       /* fix up new node's phandle field */
        if ((ibm_phandle = of_get_property(node, "ibm,phandle", NULL)))
-               node->linux_phandle = *ibm_phandle;
+               node->phandle = *ibm_phandle;
 
 out:
        of_node_put(parent);
 
                        continue;
                vic_handles = of_get_property(spu_dn, "vicinity", &lenp);
                for (i=0; i < (lenp / sizeof(phandle)); i++) {
-                       if (vic_handles[i] == target->linux_phandle)
+                       if (vic_handles[i] == target->phandle)
                                return spu;
                }
        }
 
                        if (strcmp(name, "spe") == 0) {
                                spu = devnode_spu(cbe, vic_dn);
-                               avoid_ph = last_spu_dn->linux_phandle;
+                               avoid_ph = last_spu_dn->phandle;
                        } else {
                                /*
                                 * "mic-tm" and "bif0" nodes do not have
                                        last_spu->has_mem_affinity = 1;
                                        spu->has_mem_affinity = 1;
                                }
-                               avoid_ph = vic_dn->linux_phandle;
+                               avoid_ph = vic_dn->phandle;
                        }
 
                        list_add_tail(&spu->aff_list, &last_spu->aff_list);
 
        list_for_each_entry(func, &dev->functions, link) {
                if (name && strcmp(name, func->name))
                        continue;
-               if (func->phandle && target->node != func->phandle)
+               if (func->phandle && target->phandle != func->phandle)
                        continue;
                if ((func->flags & flags) == 0)
                        continue;
 
 
        cur_inst = 0;
        for_each_node_by_type(dp, "cpu") {
-               int err = check_cpu_node(dp->node, &cur_inst,
+               int err = check_cpu_node(dp->phandle, &cur_inst,
                                         compare, compare_arg,
                                         prom_node, mid);
                if (!err) {
 
        if (!parent)
                dev_set_name(&op->dev, "root");
        else
-               dev_set_name(&op->dev, "%08x", dp->node);
+               dev_set_name(&op->dev, "%08x", dp->phandle);
 
        if (of_device_register(op)) {
                printk("%s: Could not register of device.\n",
 
        if (!parent)
                dev_set_name(&op->dev, "root");
        else
-               dev_set_name(&op->dev, "%08x", dp->node);
+               dev_set_name(&op->dev, "%08x", dp->phandle);
 
        if (of_device_register(op)) {
                printk("%s: Could not register of device.\n",
 
        struct device_node *np;
 
        for (np = allnodes; np; np = np->allnext)
-               if (np->node == handle)
+               if (np->phandle == handle)
                        break;
 
        return np;
                        void *old_val = prop->value;
                        int ret;
 
-                       ret = prom_setprop(dp->node, name, val, len);
+                       ret = prom_setprop(dp->phandle, name, val, len);
 
                        err = -EINVAL;
                        if (ret >= 0) {
 
        dp->name = get_one_property(node, "name");
        dp->type = get_one_property(node, "device_type");
-       dp->node = node;
+       dp->phandle = node;
 
        dp->properties = build_prop_list(node);
 
 
        nextp = &allnodes->allnext;
        allnodes->child = prom_build_tree(allnodes,
-                                         prom_getchild(allnodes->node),
+                                         prom_getchild(allnodes->phandle),
                                          &nextp);
        of_console_init();
 
 
        } else {
                struct device_node *dp = of_find_node_by_cpuid(cpu);
 
-               prom_startcpu(dp->node, entry, cookie);
+               prom_startcpu(dp->phandle, entry, cookie);
        }
 
        for (timeout = 0; timeout < 50000; timeout++) {
 
                                        __alignof__(struct property));
                if (allnextpp) {
                        if (strcmp(pname, "linux,phandle") == 0) {
-                               np->node = *((u32 *)*p);
-                               if (np->linux_phandle == 0)
-                                       np->linux_phandle = np->node;
+                               if (np->phandle == 0)
+                                       np->phandle = *((u32 *)*p);
                        }
                        if (strcmp(pname, "ibm,phandle") == 0)
-                               np->linux_phandle = *((u32 *)*p);
+                               np->phandle = *((u32 *)*p);
                        pp->name = pname;
                        pp->length = sz;
                        pp->value = (void *)*p;
 
 
        ph = 0;
        if (dp)
-               ph = dp->node;
+               ph = dp->phandle;
 
        data->current_node = dp;
        *((int *) op->oprom_array) = ph;
 
                dp = pci_device_to_OF_node(pdev);
                data->current_node = dp;
-               *((int *)op->oprom_array) = dp->node;
+               *((int *)op->oprom_array) = dp->phandle;
                op->oprom_size = sizeof(int);
                err = copyout(argp, op, bufsize + sizeof(int));
 
 
        dp = of_find_node_by_path(op->oprom_array);
        if (dp)
-               ph = dp->node;
+               ph = dp->phandle;
        data->current_node = dp;
        *((int *)op->oprom_array) = ph;
        op->oprom_size = sizeof(int);
                }
        }
        if (dp)
-               nd = dp->node;
+               nd = dp->phandle;
        if (copy_to_user(argp, &nd, sizeof(phandle)))
                return -EFAULT;
 
        case OPIOCGETOPTNODE:
                BUILD_BUG_ON(sizeof(phandle) != sizeof(int));
 
-               if (copy_to_user(argp, &options_node->node, sizeof(phandle)))
+               if (copy_to_user(argp, &options_node->phandle, sizeof(phandle)))
                        return -EFAULT;
 
                return 0;
 
        }
 
        dp = pci_device_to_OF_node(pdev);
-       if (node == dp->node) {
+       if (node == dp->phandle) {
                struct fb_var_screeninfo *var = &default_var;
                unsigned int N, P, Q, M, T, R;
                u32 v_total, h_total;
 
 struct device_node {
        const char *name;
        const char *type;
-       phandle node;
-#if !defined(CONFIG_SPARC)
-       phandle linux_phandle;
-#endif
+       phandle phandle;
        char    *full_name;
 
        struct  property *properties;
 
                                "required property %s not present\n", propname);
                        return -ENODEV;
                }
-               if (*ref != codec->node->linux_phandle) {
+               if (*ref != codec->node->phandle) {
                        printk(KERN_INFO "snd-aoa-fabric-layout: "
                                "%s doesn't match!\n", propname);
                        return -ENODEV;