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