arch/x86/kernel/devicetree.c

   1 /*
   2  * Architecture specific OF callbacks.
   3  */
   4 #include <linux/bootmem.h>
   5 #include <linux/export.h>
   6 #include <linux/io.h>
   7 #include <linux/irqdomain.h>
   8 #include <linux/interrupt.h>
   9 #include <linux/list.h>
  10 #include <linux/of.h>
  11 #include <linux/of_fdt.h>
  12 #include <linux/of_address.h>
  13 #include <linux/of_platform.h>
  14 #include <linux/of_irq.h>
  15 #include <linux/slab.h>
  16 #include <linux/pci.h>
  17 #include <linux/of_pci.h>
  18 #include <linux/initrd.h>
  19
  20 #include <asm/hpet.h>
  21 #include <asm/apic.h>
  22 #include <asm/pci_x86.h>
  23 #include <asm/setup.h>
  24
  25 __initdata u64 initial_dtb;
  26 char __initdata cmd_line[COMMAND_LINE_SIZE];
  27
  28 int __initdata of_ioapic;
  29
  30 void __init early_init_dt_scan_chosen_arch(unsigned long node)
  31 {
  32         BUG();
  33 }
  34
  35 void __init early_init_dt_add_memory_arch(u64 base, u64 size)
  36 {
  37         BUG();
  38 }
  39
  40 void * __init early_init_dt_alloc_memory_arch(u64 size, u64 align)
  41 {
  42         return __alloc_bootmem(size, align, __pa(MAX_DMA_ADDRESS));
  43 }
  44
  45 void __init add_dtb(u64 data)
  46 {
  47         initial_dtb = data + offsetof(struct setup_data, data);
  48 }
  49
  50 /*
  51  * CE4100 ids. Will be moved to machine_device_initcall() once we have it.
  52  */
  53 static struct of_device_id __initdata ce4100_ids[] = {
  54         { .compatible = "intel,ce4100-cp", },
  55         { .compatible = "isa", },
  56         { .compatible = "pci", },
  57         {},
  58 };
  59
  60 static int __init add_bus_probe(void)
  61 {
  62         if (!of_have_populated_dt())
  63                 return 0;
  64
  65         return of_platform_bus_probe(NULL, ce4100_ids, NULL);
  66 }
  67 module_init(add_bus_probe);
  68
  69 #ifdef CONFIG_PCI
  70 struct device_node *pcibios_get_phb_of_node(struct pci_bus *bus)
  71 {
  72         struct device_node *np;
  73
  74         for_each_node_by_type(np, "pci") {
  75                 const void *prop;
  76                 unsigned int bus_min;
  77
  78                 prop = of_get_property(np, "bus-range", NULL);
  79                 if (!prop)
  80                         continue;
  81                 bus_min = be32_to_cpup(prop);
  82                 if (bus->number == bus_min)
  83                         return np;
  84         }
  85         return NULL;
  86 }
  87
  88 static int x86_of_pci_irq_enable(struct pci_dev *dev)
  89 {
  90         struct of_irq oirq;
  91         u32 virq;
  92         int ret;
  93         u8 pin;
  94
  95         ret = pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &pin);
  96         if (ret)
  97                 return ret;
  98         if (!pin)
  99                 return 0;
 100
 101         ret = of_irq_map_pci(dev, &oirq);
 102         if (ret)
 103                 return ret;
 104
 105         virq = irq_create_of_mapping(oirq.controller, oirq.specifier,
 106                         oirq.size);
 107         if (virq == 0)
 108                 return -EINVAL;
 109         dev->irq = virq;
 110         return 0;
 111 }
 112
 113 static void x86_of_pci_irq_disable(struct pci_dev *dev)
 114 {
 115 }
 116
 117 void x86_of_pci_init(void)
 118 {
 119         pcibios_enable_irq = x86_of_pci_irq_enable;
 120         pcibios_disable_irq = x86_of_pci_irq_disable;
 121 }
 122 #endif
 123
 124 static void __init dtb_setup_hpet(void)
 125 {
 126 #ifdef CONFIG_HPET_TIMER
 127         struct device_node *dn;
 128         struct resource r;
 129         int ret;
 130
 131         dn = of_find_compatible_node(NULL, NULL, "intel,ce4100-hpet");
 132         if (!dn)
 133                 return;
 134         ret = of_address_to_resource(dn, 0, &r);
 135         if (ret) {
 136                 WARN_ON(1);
 137                 return;
 138         }
 139         hpet_address = r.start;
 140 #endif
 141 }
 142
 143 static void __init dtb_lapic_setup(void)
 144 {
 145 #ifdef CONFIG_X86_LOCAL_APIC
 146         struct device_node *dn;
 147         struct resource r;
 148         int ret;
 149
 150         dn = of_find_compatible_node(NULL, NULL, "intel,ce4100-lapic");
 151         if (!dn)
 152                 return;
 153
 154         ret = of_address_to_resource(dn, 0, &r);
 155         if (WARN_ON(ret))
 156                 return;
 157
 158         /* Did the boot loader setup the local APIC ? */
 159         if (!cpu_has_apic) {
 160                 if (apic_force_enable(r.start))
 161                         return;
 162         }
 163         smp_found_config = 1;
 164         pic_mode = 1;
 165         register_lapic_address(r.start);
 166         generic_processor_info(boot_cpu_physical_apicid,
 167                                GET_APIC_VERSION(apic_read(APIC_LVR)));
 168 #endif
 169 }
 170
 171 #ifdef CONFIG_X86_IO_APIC
 172 static unsigned int ioapic_id;
 173
 174 static void __init dtb_add_ioapic(struct device_node *dn)
 175 {
 176         struct resource r;
 177         int ret;
 178
 179         ret = of_address_to_resource(dn, 0, &r);
 180         if (ret) {
 181                 printk(KERN_ERR "Can't obtain address from node %s.\n",
 182                                 dn->full_name);
 183                 return;
 184         }
 185         mp_register_ioapic(++ioapic_id, r.start, gsi_top);
 186 }
 187
 188 static void __init dtb_ioapic_setup(void)
 189 {
 190         struct device_node *dn;
 191
 192         for_each_compatible_node(dn, NULL, "intel,ce4100-ioapic")
 193                 dtb_add_ioapic(dn);
 194
 195         if (nr_ioapics) {
 196                 of_ioapic = 1;
 197                 return;
 198         }
 199         printk(KERN_ERR "Error: No information about IO-APIC in OF.\n");
 200 }
 201 #else
 202 static void __init dtb_ioapic_setup(void) {}
 203 #endif
 204
 205 static void __init dtb_apic_setup(void)
 206 {
 207         dtb_lapic_setup();
 208         dtb_ioapic_setup();
 209 }
 210
 211 #ifdef CONFIG_OF_FLATTREE
 212 static void __init x86_flattree_get_config(void)
 213 {
 214         u32 size, map_len;
 215         struct boot_param_header *dt;
 216
 217         if (!initial_dtb)
 218                 return;
 219
 220         map_len = max(PAGE_SIZE - (initial_dtb & ~PAGE_MASK),
 221                         (u64)sizeof(struct boot_param_header));
 222
 223         dt = early_memremap(initial_dtb, map_len);
 224         size = be32_to_cpu(dt->totalsize);
 225         if (map_len < size) {
 226                 early_iounmap(dt, map_len);
 227                 dt = early_memremap(initial_dtb, size);
 228                 map_len = size;
 229         }
 230
 231         initial_boot_params = dt;
 232         unflatten_and_copy_device_tree();
 233         early_iounmap(dt, map_len);
 234 }
 235 #else
 236 static inline void x86_flattree_get_config(void) { }
 237 #endif
 238
 239 void __init x86_dtb_init(void)
 240 {
 241         x86_flattree_get_config();
 242
 243         if (!of_have_populated_dt())
 244                 return;
 245
 246         dtb_setup_hpet();
 247         dtb_apic_setup();
 248 }
 249
 250 #ifdef CONFIG_X86_IO_APIC
 251
 252 struct of_ioapic_type {
 253         u32 out_type;
 254         u32 trigger;
 255         u32 polarity;
 256 };
 257
 258 static struct of_ioapic_type of_ioapic_type[] =
 259 {
 260         {
 261                 .out_type       = IRQ_TYPE_EDGE_RISING,
 262                 .trigger        = IOAPIC_EDGE,
 263                 .polarity       = 1,
 264         },
 265         {
 266                 .out_type       = IRQ_TYPE_LEVEL_LOW,
 267                 .trigger        = IOAPIC_LEVEL,
 268                 .polarity       = 0,
 269         },
 270         {
 271                 .out_type       = IRQ_TYPE_LEVEL_HIGH,
 272                 .trigger        = IOAPIC_LEVEL,
 273                 .polarity       = 1,
 274         },
 275         {
 276                 .out_type       = IRQ_TYPE_EDGE_FALLING,
 277                 .trigger        = IOAPIC_EDGE,
 278                 .polarity       = 0,
 279         },
 280 };
 281
 282 static int ioapic_xlate(struct irq_domain *domain,
 283                         struct device_node *controller,
 284                         const u32 *intspec, u32 intsize,
 285                         irq_hw_number_t *out_hwirq, u32 *out_type)
 286 {
 287         struct io_apic_irq_attr attr;
 288         struct of_ioapic_type *it;
 289         u32 line, idx;
 290         int rc;
 291
 292         if (WARN_ON(intsize < 2))
 293                 return -EINVAL;
 294
 295         line = intspec[0];
 296
 297         if (intspec[1] >= ARRAY_SIZE(of_ioapic_type))
 298                 return -EINVAL;
 299
 300         it = &of_ioapic_type[intspec[1]];
 301
 302         idx = (u32) domain->host_data;
 303         set_io_apic_irq_attr(&attr, idx, line, it->trigger, it->polarity);
 304
 305         rc = io_apic_setup_irq_pin_once(irq_find_mapping(domain, line),
 306                                         cpu_to_node(0), &attr);
 307         if (rc)
 308                 return rc;
 309
 310         *out_hwirq = line;
 311         *out_type = it->out_type;
 312         return 0;
 313 }
 314
 315 const struct irq_domain_ops ioapic_irq_domain_ops = {
 316         .xlate = ioapic_xlate,
 317 };
 318
 319 static void dt_add_ioapic_domain(unsigned int ioapic_num,
 320                 struct device_node *np)
 321 {
 322         struct irq_domain *id;
 323         struct mp_ioapic_gsi *gsi_cfg;
 324         int ret;
 325         int num;
 326
 327         gsi_cfg = mp_ioapic_gsi_routing(ioapic_num);
 328         num = gsi_cfg->gsi_end - gsi_cfg->gsi_base + 1;
 329
 330         id = irq_domain_add_linear(np, num, &ioapic_irq_domain_ops,
 331                         (void *)ioapic_num);
 332         BUG_ON(!id);
 333         if (gsi_cfg->gsi_base == 0) {
 334                 /*
 335                  * The first NR_IRQS_LEGACY irq descs are allocated in
 336                  * early_irq_init() and need just a mapping. The
 337                  * remaining irqs need both. All of them are preallocated
 338                  * and assigned so we can keep the 1:1 mapping which the ioapic
 339                  * is having.
 340                  */
 341                 irq_domain_associate_many(id, 0, 0, NR_IRQS_LEGACY);
 342
 343                 if (num > NR_IRQS_LEGACY) {
 344                         ret = irq_create_strict_mappings(id, NR_IRQS_LEGACY,
 345                                         NR_IRQS_LEGACY, num - NR_IRQS_LEGACY);
 346                         if (ret)
 347                                 pr_err("Error creating mapping for the "
 348                                                 "remaining IRQs: %d\n", ret);
 349                 }
 350                 irq_set_default_host(id);
 351         } else {
 352                 ret = irq_create_strict_mappings(id, gsi_cfg->gsi_base, 0, num);
 353                 if (ret)
 354                         pr_err("Error creating IRQ mapping: %d\n", ret);
 355         }
 356 }
 357
 358 static void __init ioapic_add_ofnode(struct device_node *np)
 359 {
 360         struct resource r;
 361         int i, ret;
 362
 363         ret = of_address_to_resource(np, 0, &r);
 364         if (ret) {
 365                 printk(KERN_ERR "Failed to obtain address for %s\n",
 366                                 np->full_name);
 367                 return;
 368         }
 369
 370         for (i = 0; i < nr_ioapics; i++) {
 371                 if (r.start == mpc_ioapic_addr(i)) {
 372                         dt_add_ioapic_domain(i, np);
 373                         return;
 374                 }
 375         }
 376         printk(KERN_ERR "IOxAPIC at %s is not registered.\n", np->full_name);
 377 }
 378
 379 void __init x86_add_irq_domains(void)
 380 {
 381         struct device_node *dp;
 382
 383         if (!of_have_populated_dt())
 384                 return;
 385
 386         for_each_node_with_property(dp, "interrupt-controller") {
 387                 if (of_device_is_compatible(dp, "intel,ce4100-ioapic"))
 388                         ioapic_add_ofnode(dp);
 389         }
 390 }
 391 #else
 392 void __init x86_add_irq_domains(void) { }
 393 #endif