/* Force re-assigning all resources (ignore firmware
         * setup completely)
         */
-       PPC_PCI_REASSIGN_ALL_RSRC       = 0x00000001,
+       PCI_REASSIGN_ALL_RSRC   = 0x00000001,
 
        /* Re-assign all bus numbers */
-       PPC_PCI_REASSIGN_ALL_BUS        = 0x00000002,
+       PCI_REASSIGN_ALL_BUS    = 0x00000002,
 
        /* Do not try to assign, just use existing setup */
-       PPC_PCI_PROBE_ONLY              = 0x00000004,
+       PCI_PROBE_ONLY          = 0x00000004,
 
        /* Don't bother with ISA alignment unless the bridge has
         * ISA forwarding enabled
         */
-       PPC_PCI_CAN_SKIP_ISA_ALIGN      = 0x00000008,
+       PCI_CAN_SKIP_ISA_ALIGN  = 0x00000008,
 
        /* Enable domain numbers in /proc */
-       PPC_PCI_ENABLE_PROC_DOMAINS     = 0x00000010,
+       PCI_ENABLE_PROC_DOMAINS = 0x00000010,
        /* ... except for domain 0 */
-       PPC_PCI_COMPAT_DOMAIN_0         = 0x00000020,
+       PCI_COMPAT_DOMAIN_0             = 0x00000020,
 };
 #ifdef CONFIG_PCI
-extern unsigned int ppc_pci_flags;
+extern unsigned int pci_flags;
 
-static inline void ppc_pci_set_flags(int flags)
+static inline void pci_set_flags(int flags)
 {
-       ppc_pci_flags = flags;
+       pci_flags = flags;
 }
 
-static inline void ppc_pci_add_flags(int flags)
+static inline void pci_add_flags(int flags)
 {
-       ppc_pci_flags |= flags;
+       pci_flags |= flags;
 }
 
-static inline int ppc_pci_has_flag(int flag)
+static inline int pci_has_flag(int flag)
 {
-       return (ppc_pci_flags & flag);
+       return (pci_flags & flag);
 }
 #else
-static inline void ppc_pci_set_flags(int flags) { }
-static inline void ppc_pci_add_flags(int flags) { }
-static inline int ppc_pci_has_flag(int flag)
+static inline void pci_set_flags(int flags) { }
+static inline void pci_add_flags(int flags) { }
+static inline int pci_has_flag(int flag)
 {
        return 0;
 }
 
  * bus numbers (don't do that on ppc64 yet !)
  */
 #define pcibios_assign_all_busses() \
-       (ppc_pci_has_flag(PPC_PCI_REASSIGN_ALL_BUS))
+       (pci_has_flag(PCI_REASSIGN_ALL_BUS))
 
 static inline void pcibios_set_master(struct pci_dev *dev)
 {
 
 resource_size_t isa_mem_base;
 
 /* Default PCI flags is 0 on ppc32, modified at boot on ppc64 */
-unsigned int ppc_pci_flags = 0;
+unsigned int pci_flags = 0;
 
 
 static struct dma_map_ops *pci_dma_ops = &dma_direct_ops;
 {
        struct pci_controller *hose = pci_bus_to_host(bus);
 
-       if (!(ppc_pci_flags & PPC_PCI_ENABLE_PROC_DOMAINS))
+       if (!pci_has_flag(PCI_ENABLE_PROC_DOMAINS))
                return 0;
-       if (ppc_pci_flags & PPC_PCI_COMPAT_DOMAIN_0)
+       if (pci_has_flag(PCI_COMPAT_DOMAIN_0))
                return hose->global_number != 0;
        return 1;
 }
                struct resource *res = dev->resource + i;
                if (!res->flags)
                        continue;
-               /* On platforms that have PPC_PCI_PROBE_ONLY set, we don't
+               /* On platforms that have PCI_PROBE_ONLY set, we don't
                 * consider 0 as an unassigned BAR value. It's technically
                 * a valid value, but linux doesn't like it... so when we can
                 * re-assign things, we do so, but if we can't, we keep it
                 * around and hope for the best...
                 */
-               if (res->start == 0 && !(ppc_pci_flags & PPC_PCI_PROBE_ONLY)) {
+               if (res->start == 0 && !pci_has_flag(PCI_PROBE_ONLY)) {
                        pr_debug("PCI:%s Resource %d %016llx-%016llx [%x] is unassigned\n",
                                 pci_name(dev), i,
                                 (unsigned long long)res->start,
        int i;
 
        /* We don't do anything if PCI_PROBE_ONLY is set */
-       if (ppc_pci_flags & PPC_PCI_PROBE_ONLY)
+       if (pci_has_flag(PCI_PROBE_ONLY))
                return 0;
 
        /* Job is a bit different between memory and IO */
 
 static int skip_isa_ioresource_align(struct pci_dev *dev)
 {
-       if ((ppc_pci_flags & PPC_PCI_CAN_SKIP_ISA_ALIGN) &&
+       if (pci_has_flag(PCI_CAN_SKIP_ISA_ALIGN) &&
            !(dev->bus->bridge_ctl & PCI_BRIDGE_CTL_ISA))
                return 1;
        return 0;
                         * and as such ensure proper re-allocation
                         * later.
                         */
-                       if (ppc_pci_flags & PPC_PCI_REASSIGN_ALL_RSRC)
+                       if (pci_has_flag(PCI_REASSIGN_ALL_RSRC))
                                goto clear_resource;
                        pr = pci_find_parent_resource(bus->self, res);
                        if (pr == res) {
        list_for_each_entry(b, &pci_root_buses, node)
                pcibios_allocate_bus_resources(b);
 
-       if (!(ppc_pci_flags & PPC_PCI_REASSIGN_ALL_RSRC)) {
+       if (!pci_has_flag(PCI_REASSIGN_ALL_RSRC)) {
                pcibios_allocate_resources(0);
                pcibios_allocate_resources(1);
        }
         * the low IO area and the VGA memory area if they intersect the
         * bus available resources to avoid allocating things on top of them
         */
-       if (!(ppc_pci_flags & PPC_PCI_PROBE_ONLY)) {
+       if (!pci_has_flag(PCI_PROBE_ONLY)) {
                list_for_each_entry(b, &pci_root_buses, node)
                        pcibios_reserve_legacy_regions(b);
        }
        /* Now, if the platform didn't decide to blindly trust the firmware,
         * we proceed to assigning things that were left unassigned
         */
-       if (!(ppc_pci_flags & PPC_PCI_PROBE_ONLY)) {
+       if (!pci_has_flag(PCI_PROBE_ONLY)) {
                pr_debug("PCI: Assigning unassigned resources...\n");
                pci_assign_unassigned_resources();
        }
 
 
        printk(KERN_INFO "PCI: Probing PCI hardware\n");
 
-       if (ppc_pci_flags & PPC_PCI_REASSIGN_ALL_BUS)
+       if (pci_has_flag(PCI_REASSIGN_ALL_BUS))
                pci_assign_all_buses = 1;
 
        /* Scan all of the recorded PCI controllers.  */
 
        ppc_md.phys_mem_access_prot = pci_phys_mem_access_prot;
 
        if (pci_probe_only)
-               ppc_pci_flags |= PPC_PCI_PROBE_ONLY;
+               pci_add_flags(PCI_PROBE_ONLY);
 
        /* On ppc64, we always enable PCI domains and we keep domain 0
         * backward compatible in /proc for video cards
         */
-       ppc_pci_flags |= PPC_PCI_ENABLE_PROC_DOMAINS | PPC_PCI_COMPAT_DOMAIN_0;
+       pci_add_flags(PCI_ENABLE_PROC_DOMAINS | PCI_COMPAT_DOMAIN_0);
 
        /* Scan all of the recorded PCI controllers.  */
        list_for_each_entry_safe(hose, tmp, &hose_list, list_node) {
 
                prop = of_get_property(of_chosen,
                                "linux,pci-assign-all-buses", NULL);
                if (prop && *prop)
-                       ppc_pci_flags |= PPC_PCI_REASSIGN_ALL_BUS;
+                       pci_add_flags(PCI_REASSIGN_ALL_BUS);
 #endif /* CONFIG_PPC32 */
        }
 }
 
        /* Find & init the BCSR CPLD */
        ep405_init_bcsr();
 
-       ppc_pci_set_flags(PPC_PCI_REASSIGN_ALL_RSRC);
+       pci_set_flags(PCI_REASSIGN_ALL_RSRC);
 }
 
 static int __init ep405_probe(void)
 
 static int __init ppc40x_probe(void)
 {
        if (of_flat_dt_match(of_get_flat_dt_root(), board)) {
-               ppc_pci_set_flags(PPC_PCI_REASSIGN_ALL_RSRC);
+               pci_set_flags(PCI_REASSIGN_ALL_RSRC);
                return 1;
        }
 
 
        if (!of_flat_dt_is_compatible(root, "ibm,walnut"))
                return 0;
 
-       ppc_pci_flags = PPC_PCI_REASSIGN_ALL_RSRC;
+       pci_set_flags(PCI_REASSIGN_ALL_RSRC);
 
        return 1;
 }
 
 {
        unsigned long root = of_get_flat_dt_root();
        if (of_flat_dt_is_compatible(root, "amcc,canyonlands")) {
-               ppc_pci_set_flags(PPC_PCI_REASSIGN_ALL_RSRC);
+               pci_set_flags(PCI_REASSIGN_ALL_RSRC);
                return 1;
                }
        return 0;
 
        if (!of_flat_dt_is_compatible(root, "ibm,ebony"))
                return 0;
 
-       ppc_pci_set_flags(PPC_PCI_REASSIGN_ALL_RSRC);
+       pci_set_flags(PCI_REASSIGN_ALL_RSRC);
 
        return 1;
 }
 
 
        for (i = 0; i < ARRAY_SIZE(board); i++) {
                if (of_flat_dt_is_compatible(root, board[i])) {
-                       ppc_pci_set_flags(PPC_PCI_REASSIGN_ALL_RSRC);
+                       pci_set_flags(PCI_REASSIGN_ALL_RSRC);
                        return 1;
                }
        }
 
        if (!of_flat_dt_is_compatible(root, "acube,sam440ep"))
                return 0;
 
-       ppc_pci_set_flags(PPC_PCI_REASSIGN_ALL_RSRC);
+       pci_set_flags(PCI_REASSIGN_ALL_RSRC);
 
        return 1;
 }
 
 
        pr_debug("Adding MPC52xx PCI host bridge %s\n", node->full_name);
 
-       ppc_pci_add_flags(PPC_PCI_REASSIGN_ALL_BUS);
+       pci_add_flags(PCI_REASSIGN_ALL_BUS);
 
        if (of_address_to_resource(node, 0, &rsrc) != 0) {
                printk(KERN_ERR "Can't get %s resources\n", node->full_name);
 
        if (of_address_to_resource(np, 0, &r) || r.end - r.start < 0x10b)
                goto err;
 
-       ppc_pci_add_flags(PPC_PCI_REASSIGN_ALL_BUS);
+       pci_add_flags(PCI_REASSIGN_ALL_BUS);
 
        hose = pcibios_alloc_controller(np);
        if (!hose)
 
                printk ("RTAS supporting Pegasos OF not found, please upgrade"
                        " your firmware\n");
        }
-       ppc_pci_add_flags(PPC_PCI_REASSIGN_ALL_BUS);
+       pci_add_flags(PCI_REASSIGN_ALL_BUS);
        /* keep the reference to the root node */
 }
 
 
 static int __init setup_uninorth(struct pci_controller *hose,
                                 struct resource *addr)
 {
-       ppc_pci_add_flags(PPC_PCI_REASSIGN_ALL_BUS);
+       pci_add_flags(PCI_REASSIGN_ALL_BUS);
        has_uninorth = 1;
        hose->ops = ¯isc_pci_ops;
        hose->cfg_addr = ioremap(addr->start + 0x800000, 0x1000);
        struct device_node *np, *root;
        struct device_node *ht = NULL;
 
-       ppc_pci_set_flags(PPC_PCI_CAN_SKIP_ISA_ALIGN);
+       pci_set_flags(PCI_CAN_SKIP_ISA_ALIGN);
 
        root = of_find_node_by_path("/");
        if (root == NULL) {
         * some offset between bus number and domains for now when we
         * assign all busses should help for now
         */
-       if (ppc_pci_has_flag(PPC_PCI_REASSIGN_ALL_BUS))
+       if (pci_has_flag(PCI_REASSIGN_ALL_BUS))
                pcibios_assign_bus_offset = 0x10;
 #endif
 }
 
                printk(KERN_WARNING "Can't get bus-range for %s, assume"
                        " bus 0\n", dev->full_name);
 
-       ppc_pci_add_flags(PPC_PCI_REASSIGN_ALL_BUS);
+       pci_add_flags(PCI_REASSIGN_ALL_BUS);
        hose = pcibios_alloc_controller(dev);
        if (!hose)
                return -ENOMEM;
                       " bus 0\n", dev->full_name);
        }
 
-       ppc_pci_add_flags(PPC_PCI_REASSIGN_ALL_BUS);
+       pci_add_flags(PCI_REASSIGN_ALL_BUS);
        hose = pcibios_alloc_controller(dev);
        if (!hose)
                return -ENOMEM;
 
 {
        setup_indirect_pci(hose, 0xfec00000, 0xfee00000, 0);
        if (of_machine_is_compatible("PowerMac1,1"))
-               ppc_pci_add_flags(PPC_PCI_REASSIGN_ALL_BUS);
+               pci_add_flags(PCI_REASSIGN_ALL_BUS);
        if (of_machine_is_compatible("AAPL,PowerBook1998"))
                grackle_set_loop_snoop(hose, 1);
 #if 0  /* Disabled for now, HW problems ??? */
 
 {
        struct device_node *np;
 
-       ppc_pci_flags |= PPC_PCI_ENABLE_PROC_DOMAINS | PPC_PCI_COMPAT_DOMAIN_0;
+       pci_add_flags(PCI_ENABLE_PROC_DOMAINS | PCI_COMPAT_DOMAIN_0);
 
 #ifdef CONFIG_PPC4xx_PCI_EXPRESS
        for_each_compatible_node(np, NULL, "ibm,plb-pciex")