git.oblomov.eu Git - linux-2.6/blob - arch/sparc64/kernel/isa.c

   1 #include <linux/kernel.h>
   2 #include <linux/init.h>
   3 #include <linux/pci.h>
   4 #include <linux/slab.h>
   5 #include <asm/oplib.h>
   6 #include <asm/prom.h>
   7 #include <asm/of_device.h>
   8 #include <asm/isa.h>
   9
  10 struct sparc_isa_bridge *isa_chain;
  11
  12 static void __init fatal_err(const char *reason)
  13 {
  14         prom_printf("ISA: fatal error, %s.\n", reason);
  15 }
  16
  17 static void __init report_dev(struct sparc_isa_device *isa_dev, int child)
  18 {
  19         if (child)
  20                 printk(" (%s)", isa_dev->prom_node->name);
  21         else
  22                 printk(" [%s", isa_dev->prom_node->name);
  23 }
  24
  25 static struct linux_prom_registers * __init
  26 isa_dev_get_resource(struct sparc_isa_device *isa_dev)
  27 {
  28         struct linux_prom_registers *pregs;
  29         unsigned long base, len;
  30         int prop_len;
  31
  32         pregs = of_get_property(isa_dev->prom_node, "reg", &prop_len);
  33
  34         /* Only the first one is interesting. */
  35         len = pregs[0].reg_size;
  36         base = (((unsigned long)pregs[0].which_io << 32) |
  37                 (unsigned long)pregs[0].phys_addr);
  38         base += isa_dev->bus->parent->io_space.start;
  39
  40         isa_dev->resource.start = base;
  41         isa_dev->resource.end   = (base + len - 1UL);
  42         isa_dev->resource.flags = IORESOURCE_IO;
  43         isa_dev->resource.name  = isa_dev->prom_node->name;
  44
  45         request_resource(&isa_dev->bus->parent->io_space,
  46                          &isa_dev->resource);
  47
  48         return pregs;
  49 }
  50
  51 static void __init isa_dev_get_irq(struct sparc_isa_device *isa_dev,
  52                                    struct linux_prom_registers *pregs)
  53 {
  54         struct of_device *op = of_find_device_by_node(isa_dev->prom_node);
  55
  56         if (!op || !op->num_irqs) {
  57                 isa_dev->irq = PCI_IRQ_NONE;
  58         } else {
  59                 isa_dev->irq = op->irqs[0];
  60         }
  61 }
  62
  63 static void __init isa_fill_children(struct sparc_isa_device *parent_isa_dev)
  64 {
  65         struct device_node *dp = parent_isa_dev->prom_node->child;
  66
  67         if (!dp)
  68                 return;
  69
  70         printk(" ->");
  71         while (dp) {
  72                 struct linux_prom_registers *regs;
  73                 struct sparc_isa_device *isa_dev;
  74
  75                 isa_dev = kmalloc(sizeof(*isa_dev), GFP_KERNEL);
  76                 if (!isa_dev) {
  77                         fatal_err("cannot allocate child isa_dev");
  78                         prom_halt();
  79                 }
  80
  81                 memset(isa_dev, 0, sizeof(*isa_dev));
  82
  83                 /* Link it in to parent. */
  84                 isa_dev->next = parent_isa_dev->child;
  85                 parent_isa_dev->child = isa_dev;
  86
  87                 isa_dev->bus = parent_isa_dev->bus;
  88                 isa_dev->prom_node = dp;
  89
  90                 regs = isa_dev_get_resource(isa_dev);
  91                 isa_dev_get_irq(isa_dev, regs);
  92
  93                 report_dev(isa_dev, 1);
  94
  95                 dp = dp->sibling;
  96         }
  97 }
  98
  99 static void __init isa_fill_devices(struct sparc_isa_bridge *isa_br)
 100 {
 101         struct device_node *dp = isa_br->prom_node->child;
 102
 103         while (dp) {
 104                 struct linux_prom_registers *regs;
 105                 struct sparc_isa_device *isa_dev;
 106
 107                 isa_dev = kmalloc(sizeof(*isa_dev), GFP_KERNEL);
 108                 if (!isa_dev) {
 109                         printk(KERN_DEBUG "ISA: cannot allocate isa_dev");
 110                         return;
 111                 }
 112
 113                 memset(isa_dev, 0, sizeof(*isa_dev));
 114
 115                 isa_dev->ofdev.node = dp;
 116                 isa_dev->ofdev.dev.parent = &isa_br->ofdev.dev;
 117                 isa_dev->ofdev.dev.bus = &isa_bus_type;
 118                 strcpy(isa_dev->ofdev.dev.bus_id, dp->path_component_name);
 119
 120                 /* Register with core */
 121                 if (of_device_register(&isa_dev->ofdev) != 0) {
 122                         printk(KERN_DEBUG "isa: device registration error for %s!\n",
 123                                isa_dev->ofdev.dev.bus_id);
 124                         kfree(isa_dev);
 125                         goto next_sibling;
 126                 }
 127
 128                 /* Link it in. */
 129                 isa_dev->next = NULL;
 130                 if (isa_br->devices == NULL) {
 131                         isa_br->devices = isa_dev;
 132                 } else {
 133                         struct sparc_isa_device *tmp = isa_br->devices;
 134
 135                         while (tmp->next)
 136                                 tmp = tmp->next;
 137
 138                         tmp->next = isa_dev;
 139                 }
 140
 141                 isa_dev->bus = isa_br;
 142                 isa_dev->prom_node = dp;
 143
 144                 regs = isa_dev_get_resource(isa_dev);
 145                 isa_dev_get_irq(isa_dev, regs);
 146
 147                 report_dev(isa_dev, 0);
 148
 149                 isa_fill_children(isa_dev);
 150
 151                 printk("]");
 152
 153         next_sibling:
 154                 dp = dp->sibling;
 155         }
 156 }
 157
 158 void __init isa_init(void)
 159 {
 160         struct pci_dev *pdev;
 161         unsigned short vendor, device;
 162         int index = 0;
 163
 164         vendor = PCI_VENDOR_ID_AL;
 165         device = PCI_DEVICE_ID_AL_M1533;
 166
 167         pdev = NULL;
 168         while ((pdev = pci_get_device(vendor, device, pdev)) != NULL) {
 169                 struct pcidev_cookie *pdev_cookie;
 170                 struct pci_pbm_info *pbm;
 171                 struct sparc_isa_bridge *isa_br;
 172                 struct device_node *dp;
 173
 174                 pdev_cookie = pdev->sysdata;
 175                 if (!pdev_cookie) {
 176                         printk("ISA: Warning, ISA bridge ignored due to "
 177                                "lack of OBP data.\n");
 178                         continue;
 179                 }
 180                 pbm = pdev_cookie->pbm;
 181                 dp = pdev_cookie->prom_node;
 182
 183                 isa_br = kmalloc(sizeof(*isa_br), GFP_KERNEL);
 184                 if (!isa_br) {
 185                         printk(KERN_DEBUG "isa: cannot allocate sparc_isa_bridge");
 186                         return;
 187                 }
 188
 189                 memset(isa_br, 0, sizeof(*isa_br));
 190
 191                 isa_br->ofdev.node = dp;
 192                 isa_br->ofdev.dev.parent = &pdev->dev;
 193                 isa_br->ofdev.dev.bus = &isa_bus_type;
 194                 strcpy(isa_br->ofdev.dev.bus_id, dp->path_component_name);
 195
 196                 /* Register with core */
 197                 if (of_device_register(&isa_br->ofdev) != 0) {
 198                         printk(KERN_DEBUG "isa: device registration error for %s!\n",
 199                                isa_br->ofdev.dev.bus_id);
 200                         kfree(isa_br);
 201                         return;
 202                 }
 203
 204                 /* Link it in. */
 205                 isa_br->next = isa_chain;
 206                 isa_chain = isa_br;
 207
 208                 isa_br->parent = pbm;
 209                 isa_br->self = pdev;
 210                 isa_br->index = index++;
 211                 isa_br->prom_node = pdev_cookie->prom_node;
 212
 213                 printk("isa%d:", isa_br->index);
 214
 215                 isa_fill_devices(isa_br);
 216
 217                 printk("\n");
 218         }
 219 }