Splits x86 into 32 and 64 bit (XCC)
[akaros.git] / kern / arch / x86 / ioapic.c
1 /*
2  * Copyright (c) 2009 The Regents of the University of California
3  * See LICENSE for details.
4  */
5
6 #ifdef __SHARC__
7 #pragma nosharc
8 #endif
9 // Not currently sharc complient.
10
11 /** @file
12  * @brief Basic IOAPIC Driver.
13  *
14  * This file is responsible for the initalization of the Intel x58 IOAPIC(s)
15  * Once the IOAPIC is setup, the function ioapic_route_irq() can be used
16  * to route
17  *
18  * See Ch 17.5.26 in Intel X58 Express Chipset Datasheet
19  *
20  * @author Paul Pearce <pearce@eecs.berkeley.edu>
21  *
22  * @todo Come up with an impliment a concurrency model for use of the route/unroute functions
23  * @todo Once we begin using logical core ID's for groups, adjust route/unroute to utilize this (adjust high word)
24  * @todo Some notion of a 'initalized' flag we can check to ensure bootup call order.
25  *
26  * TODO: fix the formatting and make helper functions.  it's hard to see what
27  * the heck is going on, esp with the rite_mmregs. */
28
29 #include <arch/mmu.h>
30 #include <arch/x86.h>
31 #include <arch/apic.h>
32 #include <arch/mptables.h>
33 #include <arch/pci.h>
34
35 ioapic_redirect_t ioapic_redirects[NUM_IRQS];
36
37 /**
38  * @brief Parse the entries from the mptables relevant to the IOAPIC and initalize the IOAPIC and its data structures
39  *
40  * This function will loop over the data structures created by MPTables to represent ISA and PCI interrupts
41  * and then setup the ioapic_redirects array to map IRQs->IOAPIC/Flags
42  * 
43  * This function must be called during bootup, before interrupts are rerouted, and after the PCI/MPTable initilization.
44  */
45 void ioapic_init() {
46         
47         // Set all entires invalid.
48         // We define a entry to be invalid by having an ioapic_address of NULL (0x0)
49         memset(ioapic_redirects, 0x0, sizeof(ioapic_redirects));
50         
51         extern volatile uint32_t num_cpus;
52         uint32_t num_inconsistent_pci_mappings = 0;     // Increment if we find inconsistent mappings between
53                                                                                                 //  mptables and the pci bus.
54         
55         // Pull in all the stuff we need from mptables and the pci parsing. These are all stack allocated (cant be null)
56         extern pci_int_device_t pci_int_devices[PCI_MAX_BUS][PCI_MAX_DEV];
57         extern ioapic_entry_t ioapic_entries[IOAPIC_MAX_ID];
58         extern isa_int_entry_t isa_int_entries[NUM_IRQS];
59         
60         // Setup the PCI entries
61         for (int i = 0; i < NUM_IRQS; i++) {
62                 // Bus is 16 bits as we use a sential BUS value (INVALID_BUS) to denote an invalid bus
63                 //  and this valid is out of the range 0->2^8-1
64                 uint16_t bus = irq_pci_map[i]->bus;
65                 uint8_t dev = irq_pci_map[i]->dev;
66                 uint8_t line = irq_pci_map[i]->irqpin;  // Paul's line, not the irqline
67                 
68                 if (bus == INVALID_BUS)
69                         continue;
70
71                 // We do the same trick with the dest apic ID as we do with the PCI Bus, so its wider.
72                 /* might be issues with the 'line' for INTA being 0x01 now */
73                 uint16_t dst_apic_id = pci_int_devices[bus][dev].line[line].dst_apic_id;
74                 uint8_t dst_apic_int = pci_int_devices[bus][dev].line[line].dst_apic_int;
75                 
76                 // Check if this entry has been set
77                 if (dst_apic_id == INVALID_DEST_APIC) {
78                         // If we have a valid bus in the irq->pci map, and the pic->int entry doesnt exist, we have a (probably VM) problem
79                         if (num_inconsistent_pci_mappings == 0)
80                                 printk("WARNING: INCONSISTENT IRQ->PCI AND PCI->IOAPIC MAPPINGS. Trying to cope...\n");
81                         num_inconsistent_pci_mappings++;
82                         continue;
83                 }
84                 
85                 // If the lowest bit of the apic flags is set to 0, it means the ioapic is not usable (by MP Spec)
86                 // We also use this to denote non-existent ioapics in our map
87                 if ((ioapic_entries[dst_apic_id].apic_flags & 0x1) == 0) 
88                         panic("IRQ SAYS ITS GOING TO AN IOAPIC LISTED AS INVALID, THATS BAD.");
89                                         
90                 ioapic_redirects[i].ioapic_address = ioapic_entries[dst_apic_id].apic_address;
91                 ioapic_redirects[i].ioapic_int = dst_apic_int;
92                 ioapic_redirects[i].ioapic_flags = IOAPIC_PCI_FLAGS;
93         }
94         
95         // Setup the ISA entries
96         for (int i = 0; i < NUM_IRQS; i++) {
97                 
98                 uint16_t dst_apic_id = isa_int_entries[i].dst_apic_id;
99                 uint8_t dst_apic_int = isa_int_entries[i].dst_apic_int;
100                 
101                 
102                 // Skip invalid entries
103                 if (dst_apic_id == INVALID_DEST_APIC)
104                         continue;
105                         
106                 if (ioapic_redirects[i].ioapic_address != 0) {
107                         // This is technically a lie. We could in theory handle this, so long as
108                         //  everything agrees.... however this shouldnt ever really happen
109                         //  as this means we have both PCI and ISA claiming an interrupt
110                         panic("BOTH PCI AND ISA CLAIM TO SHARE AN IRQ. BAD");
111                 }
112                 
113                 // Code to check if this isa irq entry claims to be pci
114                 uint16_t pci_bus = irq_pci_map[i]->bus;
115                 /* TODO: this stuff probably doesn't work right anymore */
116                 if (pci_bus != INVALID_BUS) {
117                         // PCI bus had an entry for this irq, but we didn't set it during our pci run
118                         //  This means it is likely a broken mptable implimentation. this happens on bochs and kvm
119                         //  lets just set the flags as if its broken, and move on. Hopefully it will work out.
120                         ioapic_redirects[i].ioapic_flags = IOAPIC_BROKEN_PCI_FLAGS;
121                         num_inconsistent_pci_mappings--;
122                 }
123                 else {
124                         ioapic_redirects[i].ioapic_flags = IOAPIC_ISA_FLAGS;
125                 }
126                 
127
128                 ioapic_redirects[i].ioapic_address = ioapic_entries[dst_apic_id].apic_address;
129                 ioapic_redirects[i].ioapic_int = dst_apic_int;
130         }
131         
132         // Things didn't balance out when we scanned the isa bus for the missing pci devices. Die.
133         if (num_inconsistent_pci_mappings != 0) 
134                 panic("FAILED TO COPE WITH INCONSISTENT IRQ->PCI AND PCI->IOAPIC MAPPINGS!");
135         
136         // Support for other type of IRQ's goes here.
137         
138         /* Note: We do not technically ever do anything to initalize the IOAPIC
139         *   According to the x58 chipset spec, this is done for us. It starts up
140         *   usable and with everything masked, so there isn't really anything to do
141         *   besides setup our structures.
142         */
143 }
144
145
146 /** @brief Reconfigure the correct IOAPIC to route a given irq to a given dest
147   * 
148   * This function will take an irq given by 'irq' and using the interal IOAPIC
149   * strucures will adjust the IOAPIC to properly route that IRQ to a core 
150   * (or in the future group of cores) specified by the 'dest' bits.
151   *
152   * This function must be called after ioapic_init() is called.
153   *
154   * There is no notion of success besides invalid data, which casues a panic.
155   *
156   * @todo Logical partition support
157   * @todo Decide on a synchronization mechinism
158   *
159   * @param[in] irq      The IRQ we are trying to route. This is non-kernal-offseted. EX: Pit is IRQ 0, not 32.
160   * @param[in] dest     The core id we want to route irq to
161   */
162
163 void ioapic_route_irq(uint8_t irq, uint8_t dest) {
164         
165         if (((irq + KERNEL_IRQ_OFFSET) >= NUM_IRQS) ||
166             (ioapic_redirects[irq].ioapic_address == 0)) {
167                 panic("TRYING TO REROUTE AN INVALID IRQ!");
168         }
169
170         // THIS IS A TEMP CHECK. IF WE USE LOGICAL PARTITIONS THIS MUST BE REMOVED
171         extern volatile uint32_t num_cpus;
172         if (dest >= num_cpus)
173                 panic("TRYING TO REROUTE TO AN INVALID DESTINATION!");
174         
175         if (irq == 0 && dest != 0)
176                 cprintf("WARNING: Rerouting IRQ to core != 0 may cause undefined behavior!\n");
177
178         // Bit pack our redirection entry. This is black magic based on the spec. See the x58 spec.
179         uint32_t redirect_low = KERNEL_IRQ_OFFSET + irq;
180         redirect_low = redirect_low | (ioapic_redirects[irq].ioapic_flags << 8);
181         uint32_t redirect_high = dest << 24;
182         
183         // YOU MUST MUST MUST MUST MUST MUST MUST write the high bits first. If you don't, you get interrupts going to crazy places
184         // Ask Paul about that afternoon of his life.
185         write_mmreg32(ioapic_redirects[irq].ioapic_address , IOAPIC_REDIRECT_OFFSET + 2*ioapic_redirects[irq].ioapic_int + 1);
186         write_mmreg32(ioapic_redirects[irq].ioapic_address  + IOAPIC_WRITE_WINDOW_OFFSET, redirect_high);
187         write_mmreg32(ioapic_redirects[irq].ioapic_address , IOAPIC_REDIRECT_OFFSET + 2*ioapic_redirects[irq].ioapic_int);
188         write_mmreg32(ioapic_redirects[irq].ioapic_address  + IOAPIC_WRITE_WINDOW_OFFSET, redirect_low);
189 }
190
191 /** @brief Reconfigure the correct IOAPIC to no longer route a given irq to any core
192   * 
193   * This function will take an irq given by 'irq' and using the interal IOAPIC
194   * strucures will adjust the IOAPIC to no longer route that irq to any destination
195   *
196   * This function must be called after ioapic_init() is called, but need not be called after a matching ioapic_route_irq()
197   *
198   * There is no notion of success besides invalid data, which casues a panic.
199   *
200   * @todo Decide on a synchronization mechinism
201   * 
202   * @param[in] irq      The IRQ we are trying to unroute. This is non-kernal-offseted. EX: Pit is IRQ 0, not 32.
203   */
204 void ioapic_unroute_irq(uint8_t irq) {
205
206         if (((irq + KERNEL_IRQ_OFFSET) >= NUM_IRQS) ||
207             (ioapic_redirects[irq].ioapic_address == 0)) {
208                 panic("TRYING TO REROUTE AN INVALID IRQ!");
209         }
210         
211         // Must write low first, else we will reroute to a wrong core for a split before turning off
212         write_mmreg32(ioapic_redirects[irq].ioapic_address , IOAPIC_REDIRECT_OFFSET + 2*ioapic_redirects[irq].ioapic_int);
213         write_mmreg32(ioapic_redirects[irq].ioapic_address  + IOAPIC_WRITE_WINDOW_OFFSET, IOAPIC_UNROUTE_LOW);
214         
215         write_mmreg32(ioapic_redirects[irq].ioapic_address , IOAPIC_REDIRECT_OFFSET + 2*ioapic_redirects[irq].ioapic_int + 1);
216         write_mmreg32(ioapic_redirects[irq].ioapic_address  + IOAPIC_WRITE_WINDOW_OFFSET, IOAPIC_UNROUTE_HIGH);
217
218 }