redonkable/alistair23-linux
redonkable/alistair23-linux
1
0
Fork 0
Code Releases Activity

sparc64: Kill unused local ISA bus layer.

Browse source 
No more drivers use this, and therefore it can die.

Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David S. Miller 2008-04-26 21:07:35 -07:00
parent 9c1a5077fd
commit 5da496e4b9
6 changed files with 1 additions and 244 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
arch/sparc64/kernel/Makefile
View file

@ -15,7 +15,7 @@ obj-y := process.o setup.o cpu.o idprom.o \
visemul.o prom.o of_device.o hvapi.o sstate.o mdesc.o
obj-$(CONFIG_STACKTRACE) += stacktrace.o
obj-$(CONFIG_PCI) += ebus.o isa.o pci_common.o \
obj-$(CONFIG_PCI) += ebus.o pci_common.o \
pci_psycho.o pci_sabre.o pci_schizo.o \
pci_sun4v.o pci_sun4v_asm.o pci_fire.o
obj-$(CONFIG_PCI_MSI) += pci_msi.o

191
arch/sparc64/kernel/isa.c
View file

@ -1,191 +0,0 @@
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/pci.h>
#include <linux/slab.h>
#include <asm/oplib.h>
#include <asm/prom.h>
#include <asm/of_device.h>
#include <asm/isa.h>
struct sparc_isa_bridge *isa_chain;
static void __init fatal_err(const char *reason)
{
prom_printf("ISA: fatal error, %s.\n", reason);
}
static void __init report_dev(struct sparc_isa_device *isa_dev, int child)
{
if (child)
printk(" (%s)", isa_dev->prom_node->name);
else
printk(" [%s", isa_dev->prom_node->name);
}
static void __init isa_dev_get_resource(struct sparc_isa_device *isa_dev)
{
struct of_device *op = of_find_device_by_node(isa_dev->prom_node);
memcpy(&isa_dev->resource, &op->resource[0], sizeof(struct resource));
}
static void __init isa_dev_get_irq(struct sparc_isa_device *isa_dev)
{
struct of_device *op = of_find_device_by_node(isa_dev->prom_node);
if (!op || !op->num_irqs) {
isa_dev->irq = PCI_IRQ_NONE;
} else {
isa_dev->irq = op->irqs[0];
}
}
static void __init isa_fill_children(struct sparc_isa_device *parent_isa_dev)
{
struct device_node *dp = parent_isa_dev->prom_node->child;
if (!dp)
return;
printk(" ->");
while (dp) {
struct sparc_isa_device *isa_dev;
isa_dev = kzalloc(sizeof(*isa_dev), GFP_KERNEL);
if (!isa_dev) {
fatal_err("cannot allocate child isa_dev");
prom_halt();
}
/* Link it in to parent. */
isa_dev->next = parent_isa_dev->child;
parent_isa_dev->child = isa_dev;
isa_dev->bus = parent_isa_dev->bus;
isa_dev->prom_node = dp;
isa_dev_get_resource(isa_dev);
isa_dev_get_irq(isa_dev);
report_dev(isa_dev, 1);
dp = dp->sibling;
}
}
static void __init isa_fill_devices(struct sparc_isa_bridge *isa_br)
{
struct device_node *dp = isa_br->prom_node->child;
while (dp) {
struct sparc_isa_device *isa_dev;
struct dev_archdata *sd;
isa_dev = kzalloc(sizeof(*isa_dev), GFP_KERNEL);
if (!isa_dev) {
printk(KERN_DEBUG "ISA: cannot allocate isa_dev");
return;
}
sd = &isa_dev->ofdev.dev.archdata;
sd->prom_node = dp;
sd->op = &isa_dev->ofdev;
sd->iommu = isa_br->ofdev.dev.parent->archdata.iommu;
sd->stc = isa_br->ofdev.dev.parent->archdata.stc;
sd->numa_node = isa_br->ofdev.dev.parent->archdata.numa_node;
isa_dev->ofdev.node = dp;
isa_dev->ofdev.dev.parent = &isa_br->ofdev.dev;
isa_dev->ofdev.dev.bus = &isa_bus_type;
sprintf(isa_dev->ofdev.dev.bus_id, "isa[%08x]", dp->node);
/* Register with core */
if (of_device_register(&isa_dev->ofdev) != 0) {
printk(KERN_DEBUG "isa: device registration error for %s!\n",
dp->path_component_name);
kfree(isa_dev);
goto next_sibling;
}
/* Link it in. */
isa_dev->next = NULL;
if (isa_br->devices == NULL) {
isa_br->devices = isa_dev;
} else {
struct sparc_isa_device *tmp = isa_br->devices;
while (tmp->next)
tmp = tmp->next;
tmp->next = isa_dev;
}
isa_dev->bus = isa_br;
isa_dev->prom_node = dp;
isa_dev_get_resource(isa_dev);
isa_dev_get_irq(isa_dev);
report_dev(isa_dev, 0);
isa_fill_children(isa_dev);
printk("]");
next_sibling:
dp = dp->sibling;
}
}
void __init isa_init(void)
{
struct pci_dev *pdev;
unsigned short vendor, device;
int index = 0;
vendor = PCI_VENDOR_ID_AL;
device = PCI_DEVICE_ID_AL_M1533;
pdev = NULL;
while ((pdev = pci_get_device(vendor, device, pdev)) != NULL) {
struct sparc_isa_bridge *isa_br;
struct device_node *dp;
dp = pci_device_to_OF_node(pdev);
isa_br = kzalloc(sizeof(*isa_br), GFP_KERNEL);
if (!isa_br) {
printk(KERN_DEBUG "isa: cannot allocate sparc_isa_bridge");
pci_dev_put(pdev);
return;
}
isa_br->ofdev.node = dp;
isa_br->ofdev.dev.parent = &pdev->dev;
isa_br->ofdev.dev.bus = &isa_bus_type;
sprintf(isa_br->ofdev.dev.bus_id, "isa%d", index);
/* Register with core */
if (of_device_register(&isa_br->ofdev) != 0) {
printk(KERN_DEBUG "isa: device registration error for %s!\n",
dp->path_component_name);
kfree(isa_br);
pci_dev_put(pdev);
return;
}
/* Link it in. */
isa_br->next = isa_chain;
isa_chain = isa_br;
isa_br->self = pdev;
isa_br->index = index++;
isa_br->prom_node = dp;
printk("isa%d:", isa_br->index);
isa_fill_devices(isa_br);
printk("\n");
}
}

2
arch/sparc64/kernel/pci.c
View file

@ -23,7 +23,6 @@
#include <asm/pgtable.h>
#include <asm/irq.h>
#include <asm/ebus.h>
#include <asm/isa.h>
#include <asm/prom.h>
#include <asm/apb.h>
@ -885,7 +884,6 @@ static int __init pcibios_init(void)
pci_scan_each_controller_bus();
isa_init();
ebus_init();
power_init();

2
arch/sparc64/kernel/sparc64_ksyms.c
View file

@ -49,7 +49,6 @@
#endif
#ifdef CONFIG_PCI
#include <asm/ebus.h>
#include <asm/isa.h>
#endif
#include <asm/ns87303.h>
#include <asm/timer.h>
@ -187,7 +186,6 @@ EXPORT_SYMBOL(insw);
EXPORT_SYMBOL(insl);
#ifdef CONFIG_PCI
EXPORT_SYMBOL(ebus_chain);
EXPORT_SYMBOL(isa_chain);
EXPORT_SYMBOL(pci_alloc_consistent);
EXPORT_SYMBOL(pci_free_consistent);
EXPORT_SYMBOL(pci_map_single);

1
include/asm-sparc64/floppy.h
View file

@ -293,7 +293,6 @@ static int sun_fd_eject(int drive)
#ifdef CONFIG_PCI
#include <asm/ebus.h>
#include <asm/isa.h>
#include <asm/ns87303.h>
static struct ebus_dma_info sun_pci_fd_ebus_dma;

47
include/asm-sparc64/isa.h
View file

@ -1,47 +0,0 @@
/* $Id: isa.h,v 1.1 2001/05/11 04:31:55 davem Exp $
* isa.h: Sparc64 layer for PCI to ISA bridge devices.
*
* Copyright (C) 2001 David S. Miller (davem@redhat.com)
*/
#ifndef __SPARC64_ISA_H
#define __SPARC64_ISA_H
#include <asm/oplib.h>
#include <asm/prom.h>
#include <asm/of_device.h>
struct sparc_isa_bridge;
struct sparc_isa_device {
struct of_device ofdev;
struct sparc_isa_device *next;
struct sparc_isa_device *child;
struct sparc_isa_bridge *bus;
struct device_node *prom_node;
struct resource resource;
unsigned int irq;
};
#define to_isa_device(d) container_of(d, struct sparc_isa_device, ofdev.dev)
struct sparc_isa_bridge {
struct of_device ofdev;
struct sparc_isa_bridge *next;
struct sparc_isa_device *devices;
struct pci_dev *self;
int index;
struct device_node *prom_node;
};
#define to_isa_bridge(d) container_of(d, struct sparc_isa_bridge, ofdev.dev)
extern struct sparc_isa_bridge *isa_chain;
extern void isa_init(void);
#define for_each_isa(bus) \
for((bus) = isa_chain; (bus); (bus) = (bus)->next)
#define for_each_isadev(dev, bus) \
for((dev) = (bus)->devices; (dev); (dev) = (dev)->next)
#endif /* !(__SPARC64_ISA_H) */