feda0341f5a73b5a921c6d858de94bf9babfbc4b
[linux-2.6.git] / drivers / acpi / pci_irq.c
1 /*
2  *  pci_irq.c - ACPI PCI Interrupt Routing ($Revision: 11 $)
3  *
4  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
5  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
6  *  Copyright (C) 2002       Dominik Brodowski <devel@brodo.de>
7  *
8  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
9  *
10  *  This program is free software; you can redistribute it and/or modify
11  *  it under the terms of the GNU General Public License as published by
12  *  the Free Software Foundation; either version 2 of the License, or (at
13  *  your option) any later version.
14  *
15  *  This program is distributed in the hope that it will be useful, but
16  *  WITHOUT ANY WARRANTY; without even the implied warranty of
17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  *  General Public License for more details.
19  *
20  *  You should have received a copy of the GNU General Public License along
21  *  with this program; if not, write to the Free Software Foundation, Inc.,
22  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
23  *
24  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
25  */
26
27
28 #include <linux/kernel.h>
29 #include <linux/module.h>
30 #include <linux/init.h>
31 #include <linux/types.h>
32 #include <linux/proc_fs.h>
33 #include <linux/spinlock.h>
34 #include <linux/pm.h>
35 #include <linux/pci.h>
36 #include <linux/acpi.h>
37 #include <acpi/acpi_bus.h>
38 #include <acpi/acpi_drivers.h>
39
40 #define _COMPONENT              ACPI_PCI_COMPONENT
41 ACPI_MODULE_NAME("pci_irq")
42
43 static struct acpi_prt_list acpi_prt;
44 static DEFINE_SPINLOCK(acpi_prt_lock);
45
46 /* --------------------------------------------------------------------------
47                          PCI IRQ Routing Table (PRT) Support
48    -------------------------------------------------------------------------- */
49
50 static struct acpi_prt_entry *acpi_pci_irq_find_prt_entry(int segment,
51                                                           int bus,
52                                                           int device, int pin)
53 {
54         struct list_head *node = NULL;
55         struct acpi_prt_entry *entry = NULL;
56
57
58         if (!acpi_prt.count)
59                 return NULL;
60
61         /*
62          * Parse through all PRT entries looking for a match on the specified
63          * PCI device's segment, bus, device, and pin (don't care about func).
64          *
65          */
66         spin_lock(&acpi_prt_lock);
67         list_for_each(node, &acpi_prt.entries) {
68                 entry = list_entry(node, struct acpi_prt_entry, node);
69                 if ((segment == entry->id.segment)
70                     && (bus == entry->id.bus)
71                     && (device == entry->id.device)
72                     && (pin == entry->pin)) {
73                         spin_unlock(&acpi_prt_lock);
74                         return entry;
75                 }
76         }
77
78         spin_unlock(&acpi_prt_lock);
79         return NULL;
80 }
81
82 static int
83 acpi_pci_irq_add_entry(acpi_handle handle,
84                        int segment, int bus, struct acpi_pci_routing_table *prt)
85 {
86         struct acpi_prt_entry *entry = NULL;
87
88
89         if (!prt)
90                 return -EINVAL;
91
92         entry = kmalloc(sizeof(struct acpi_prt_entry), GFP_KERNEL);
93         if (!entry)
94                 return -ENOMEM;
95         memset(entry, 0, sizeof(struct acpi_prt_entry));
96
97         entry->id.segment = segment;
98         entry->id.bus = bus;
99         entry->id.device = (prt->address >> 16) & 0xFFFF;
100         entry->id.function = prt->address & 0xFFFF;
101         entry->pin = prt->pin;
102
103         /*
104          * Type 1: Dynamic
105          * ---------------
106          * The 'source' field specifies the PCI interrupt link device used to
107          * configure the IRQ assigned to this slot|dev|pin.  The 'source_index'
108          * indicates which resource descriptor in the resource template (of
109          * the link device) this interrupt is allocated from.
110          * 
111          * NOTE: Don't query the Link Device for IRQ information at this time
112          *       because Link Device enumeration may not have occurred yet
113          *       (e.g. exists somewhere 'below' this _PRT entry in the ACPI
114          *       namespace).
115          */
116         if (prt->source[0]) {
117                 acpi_get_handle(handle, prt->source, &entry->link.handle);
118                 entry->link.index = prt->source_index;
119         }
120         /*
121          * Type 2: Static
122          * --------------
123          * The 'source' field is NULL, and the 'source_index' field specifies
124          * the IRQ value, which is hardwired to specific interrupt inputs on
125          * the interrupt controller.
126          */
127         else
128                 entry->link.index = prt->source_index;
129
130         ACPI_DEBUG_PRINT_RAW((ACPI_DB_INFO,
131                               "      %02X:%02X:%02X[%c] -> %s[%d]\n",
132                               entry->id.segment, entry->id.bus,
133                               entry->id.device, ('A' + entry->pin), prt->source,
134                               entry->link.index));
135
136         spin_lock(&acpi_prt_lock);
137         list_add_tail(&entry->node, &acpi_prt.entries);
138         acpi_prt.count++;
139         spin_unlock(&acpi_prt_lock);
140
141         return 0;
142 }
143
144 static void
145 acpi_pci_irq_del_entry(int segment, int bus, struct acpi_prt_entry *entry)
146 {
147         if (segment == entry->id.segment && bus == entry->id.bus) {
148                 acpi_prt.count--;
149                 list_del(&entry->node);
150                 kfree(entry);
151         }
152 }
153
154 int acpi_pci_irq_add_prt(acpi_handle handle, int segment, int bus)
155 {
156         acpi_status status = AE_OK;
157         char *pathname = NULL;
158         struct acpi_buffer buffer = { 0, NULL };
159         struct acpi_pci_routing_table *prt = NULL;
160         struct acpi_pci_routing_table *entry = NULL;
161         static int first_time = 1;
162
163
164         pathname = (char *)kmalloc(ACPI_PATHNAME_MAX, GFP_KERNEL);
165         if (!pathname)
166                 return -ENOMEM;
167         memset(pathname, 0, ACPI_PATHNAME_MAX);
168
169         if (first_time) {
170                 acpi_prt.count = 0;
171                 INIT_LIST_HEAD(&acpi_prt.entries);
172                 first_time = 0;
173         }
174
175         /* 
176          * NOTE: We're given a 'handle' to the _PRT object's parent device
177          *       (either a PCI root bridge or PCI-PCI bridge).
178          */
179
180         buffer.length = ACPI_PATHNAME_MAX;
181         buffer.pointer = pathname;
182         acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
183
184         printk(KERN_DEBUG "ACPI: PCI Interrupt Routing Table [%s._PRT]\n",
185                pathname);
186
187         /* 
188          * Evaluate this _PRT and add its entries to our global list (acpi_prt).
189          */
190
191         buffer.length = 0;
192         buffer.pointer = NULL;
193         kfree(pathname);
194         status = acpi_get_irq_routing_table(handle, &buffer);
195         if (status != AE_BUFFER_OVERFLOW) {
196                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PRT [%s]",
197                                 acpi_format_exception(status)));
198                 return -ENODEV;
199         }
200
201         prt = kmalloc(buffer.length, GFP_KERNEL);
202         if (!prt) {
203                 return -ENOMEM;
204         }
205         memset(prt, 0, buffer.length);
206         buffer.pointer = prt;
207
208         status = acpi_get_irq_routing_table(handle, &buffer);
209         if (ACPI_FAILURE(status)) {
210                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PRT [%s]",
211                                 acpi_format_exception(status)));
212                 kfree(buffer.pointer);
213                 return -ENODEV;
214         }
215
216         entry = prt;
217
218         while (entry && (entry->length > 0)) {
219                 acpi_pci_irq_add_entry(handle, segment, bus, entry);
220                 entry = (struct acpi_pci_routing_table *)
221                     ((unsigned long)entry + entry->length);
222         }
223
224         kfree(prt);
225
226         return 0;
227 }
228
229 void acpi_pci_irq_del_prt(int segment, int bus)
230 {
231         struct list_head *node = NULL, *n = NULL;
232         struct acpi_prt_entry *entry = NULL;
233
234         if (!acpi_prt.count) {
235                 return;
236         }
237
238         printk(KERN_DEBUG
239                "ACPI: Delete PCI Interrupt Routing Table for %x:%x\n", segment,
240                bus);
241         spin_lock(&acpi_prt_lock);
242         list_for_each_safe(node, n, &acpi_prt.entries) {
243                 entry = list_entry(node, struct acpi_prt_entry, node);
244
245                 acpi_pci_irq_del_entry(segment, bus, entry);
246         }
247         spin_unlock(&acpi_prt_lock);
248 }
249
250 /* --------------------------------------------------------------------------
251                           PCI Interrupt Routing Support
252    -------------------------------------------------------------------------- */
253 typedef int (*irq_lookup_func) (struct acpi_prt_entry *, int *, int *, char **);
254
255 static int
256 acpi_pci_allocate_irq(struct acpi_prt_entry *entry,
257                       int *triggering, int *polarity, char **link)
258 {
259         int irq;
260
261
262         if (entry->link.handle) {
263                 irq = acpi_pci_link_allocate_irq(entry->link.handle,
264                                                  entry->link.index, triggering,
265                                                  polarity, link);
266                 if (irq < 0) {
267                         printk(KERN_WARNING PREFIX
268                                       "Invalid IRQ link routing entry\n");
269                         return -1;
270                 }
271         } else {
272                 irq = entry->link.index;
273                 *triggering = ACPI_LEVEL_SENSITIVE;
274                 *polarity = ACPI_ACTIVE_LOW;
275         }
276
277         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found IRQ %d\n", irq));
278         return irq;
279 }
280
281 static int
282 acpi_pci_free_irq(struct acpi_prt_entry *entry,
283                   int *triggering, int *polarity, char **link)
284 {
285         int irq;
286
287         if (entry->link.handle) {
288                 irq = acpi_pci_link_free_irq(entry->link.handle);
289         } else {
290                 irq = entry->link.index;
291         }
292         return irq;
293 }
294
295 /*
296  * acpi_pci_irq_lookup
297  * success: return IRQ >= 0
298  * failure: return -1
299  */
300 static int
301 acpi_pci_irq_lookup(struct pci_bus *bus,
302                     int device,
303                     int pin,
304                     int *triggering,
305                     int *polarity, char **link, irq_lookup_func func)
306 {
307         struct acpi_prt_entry *entry = NULL;
308         int segment = pci_domain_nr(bus);
309         int bus_nr = bus->number;
310         int ret;
311
312
313         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
314                           "Searching for PRT entry for %02x:%02x:%02x[%c]\n",
315                           segment, bus_nr, device, ('A' + pin)));
316
317         entry = acpi_pci_irq_find_prt_entry(segment, bus_nr, device, pin);
318         if (!entry) {
319                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "PRT entry not found\n"));
320                 return -1;
321         }
322
323         ret = func(entry, triggering, polarity, link);
324         return ret;
325 }
326
327 /*
328  * acpi_pci_irq_derive
329  * success: return IRQ >= 0
330  * failure: return < 0
331  */
332 static int
333 acpi_pci_irq_derive(struct pci_dev *dev,
334                     int pin,
335                     int *triggering,
336                     int *polarity, char **link, irq_lookup_func func)
337 {
338         struct pci_dev *bridge = dev;
339         int irq = -1;
340         u8 bridge_pin = 0;
341
342
343         if (!dev)
344                 return -EINVAL;
345
346         /* 
347          * Attempt to derive an IRQ for this device from a parent bridge's
348          * PCI interrupt routing entry (eg. yenta bridge and add-in card bridge).
349          */
350         while (irq < 0 && bridge->bus->self) {
351                 pin = (pin + PCI_SLOT(bridge->devfn)) % 4;
352                 bridge = bridge->bus->self;
353
354                 if ((bridge->class >> 8) == PCI_CLASS_BRIDGE_CARDBUS) {
355                         /* PC card has the same IRQ as its cardbridge */
356                         bridge_pin = bridge->pin;
357                         if (!bridge_pin) {
358                                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
359                                                   "No interrupt pin configured for device %s\n",
360                                                   pci_name(bridge)));
361                                 return -1;
362                         }
363                         /* Pin is from 0 to 3 */
364                         bridge_pin--;
365                         pin = bridge_pin;
366                 }
367
368                 irq = acpi_pci_irq_lookup(bridge->bus, PCI_SLOT(bridge->devfn),
369                                           pin, triggering, polarity,
370                                           link, func);
371         }
372
373         if (irq < 0) {
374                 printk(KERN_WARNING PREFIX "Unable to derive IRQ for device %s\n",
375                               pci_name(dev));
376                 return -1;
377         }
378
379         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Derive IRQ %d for device %s from %s\n",
380                           irq, pci_name(dev), pci_name(bridge)));
381
382         return irq;
383 }
384
385 /*
386  * acpi_pci_irq_enable
387  * success: return 0
388  * failure: return < 0
389  */
390
391 int acpi_pci_irq_enable(struct pci_dev *dev)
392 {
393         int irq = 0;
394         u8 pin = 0;
395         int triggering = ACPI_LEVEL_SENSITIVE;
396         int polarity = ACPI_ACTIVE_LOW;
397         char *link = NULL;
398         int rc;
399
400
401         if (!dev)
402                 return -EINVAL;
403
404         pin = dev->pin;
405         if (!pin) {
406                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
407                                   "No interrupt pin configured for device %s\n",
408                                   pci_name(dev)));
409                 return 0;
410         }
411         pin--;
412
413         if (!dev->bus) {
414                 printk(KERN_ERR PREFIX "Invalid (NULL) 'bus' field\n");
415                 return -ENODEV;
416         }
417
418         /* 
419          * First we check the PCI IRQ routing table (PRT) for an IRQ.  PRT
420          * values override any BIOS-assigned IRQs set during boot.
421          */
422         irq = acpi_pci_irq_lookup(dev->bus, PCI_SLOT(dev->devfn), pin,
423                                   &triggering, &polarity, &link,
424                                   acpi_pci_allocate_irq);
425
426         /*
427          * If no PRT entry was found, we'll try to derive an IRQ from the
428          * device's parent bridge.
429          */
430         if (irq < 0)
431                 irq = acpi_pci_irq_derive(dev, pin, &triggering,
432                                           &polarity, &link,
433                                           acpi_pci_allocate_irq);
434
435         /*
436          * No IRQ known to the ACPI subsystem - maybe the BIOS / 
437          * driver reported one, then use it. Exit in any case.
438          */
439         if (irq < 0) {
440                 printk(KERN_WARNING PREFIX "PCI Interrupt %s[%c]: no GSI",
441                        pci_name(dev), ('A' + pin));
442                 /* Interrupt Line values above 0xF are forbidden */
443                 if (dev->irq > 0 && (dev->irq <= 0xF)) {
444                         printk(" - using IRQ %d\n", dev->irq);
445                         acpi_register_gsi(dev->irq, ACPI_LEVEL_SENSITIVE,
446                                           ACPI_ACTIVE_LOW);
447                         return 0;
448                 } else {
449                         printk("\n");
450                         return 0;
451                 }
452         }
453
454         rc = acpi_register_gsi(irq, triggering, polarity);
455         if (rc < 0) {
456                 printk(KERN_WARNING PREFIX "PCI Interrupt %s[%c]: failed "
457                        "to register GSI\n", pci_name(dev), ('A' + pin));
458                 return rc;
459         }
460         dev->irq = rc;
461
462         printk(KERN_INFO PREFIX "PCI Interrupt %s[%c] -> ",
463                pci_name(dev), 'A' + pin);
464
465         if (link)
466                 printk("Link [%s] -> ", link);
467
468         printk("GSI %u (%s, %s) -> IRQ %d\n", irq,
469                (triggering == ACPI_LEVEL_SENSITIVE) ? "level" : "edge",
470                (polarity == ACPI_ACTIVE_LOW) ? "low" : "high", dev->irq);
471
472         return 0;
473 }
474
475 EXPORT_SYMBOL(acpi_pci_irq_enable);
476
477 /* FIXME: implement x86/x86_64 version */
478 void __attribute__ ((weak)) acpi_unregister_gsi(u32 i)
479 {
480 }
481
482 void acpi_pci_irq_disable(struct pci_dev *dev)
483 {
484         int gsi = 0;
485         u8 pin = 0;
486         int triggering = ACPI_LEVEL_SENSITIVE;
487         int polarity = ACPI_ACTIVE_LOW;
488
489
490         if (!dev || !dev->bus)
491                 return;
492
493         pin = dev->pin;
494         if (!pin)
495                 return;
496         pin--;
497
498         /*
499          * First we check the PCI IRQ routing table (PRT) for an IRQ.
500          */
501         gsi = acpi_pci_irq_lookup(dev->bus, PCI_SLOT(dev->devfn), pin,
502                                   &triggering, &polarity, NULL,
503                                   acpi_pci_free_irq);
504         /*
505          * If no PRT entry was found, we'll try to derive an IRQ from the
506          * device's parent bridge.
507          */
508         if (gsi < 0)
509                 gsi = acpi_pci_irq_derive(dev, pin,
510                                           &triggering, &polarity, NULL,
511                                           acpi_pci_free_irq);
512         if (gsi < 0)
513                 return;
514
515         /*
516          * TBD: It might be worth clearing dev->irq by magic constant
517          * (e.g. PCI_UNDEFINED_IRQ).
518          */
519
520         printk(KERN_INFO PREFIX "PCI interrupt for device %s disabled\n",
521                pci_name(dev));
522
523         acpi_unregister_gsi(gsi);
524
525         return;
526 }