167a72351b59d2b65c7a8b8f1e09fd8eb9b31453
[dragonfly.git] / sys / dev / acpica5 / acpi_pci_link.c
1 /*
2  * Copyright (c) 2002 Mitsuru IWASAKI <iwasaki@jp.kfreebsd.org>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  * $FreeBSD: src/sys/dev/acpica/acpi_pci_link.c,v 1.56.2.1.6.1 2009/04/15 03:14:26 kensmith Exp $
27  */
28
29 #define MPASS(ex)               MPASS4(ex, #ex, __FILE__, __LINE__)
30 #define MPASS4(ex, what, file, line)                                    \
31         KASSERT((ex), ("Assertion %s failed at %s:%d", what, file, line))
32
33 #include "opt_acpi.h"
34 #include <sys/param.h>
35 #include <sys/bus.h>
36 #include <sys/kernel.h>
37 #include <sys/limits.h>
38 #include <sys/malloc.h>
39 #include <sys/module.h>
40
41 #include "acpi.h"
42 #include <dev/acpica5/acpivar.h>
43 #include <dev/acpica5/acpi_pcibvar.h>
44
45 #include <bus/pci/i386/pci_cfgreg.h>
46 #include <bus/pci/pcireg.h>
47 #include <bus/pci/pcivar.h>
48 #include "pcib_if.h"
49
50 /* Hooks for the ACPI CA debugging infrastructure. */
51 #define _COMPONENT      ACPI_BUS
52 ACPI_MODULE_NAME("PCI_LINK")
53
54 ACPI_SERIAL_DECL(pci_link, "ACPI PCI link");
55
56 #define NUM_ISA_INTERRUPTS      16
57 #define NUM_ACPI_INTERRUPTS     256
58
59 /*
60  * An ACPI PCI link device may contain multiple links.  Each link has its
61  * own ACPI resource.  _PRT entries specify which link is being used via
62  * the Source Index.
63  *
64  * XXX: A note about Source Indices and DPFs:  Currently we assume that
65  * the DPF start and end tags are not counted towards the index that
66  * Source Index corresponds to.  Also, we assume that when DPFs are in use
67  * they various sets overlap in terms of Indices.  Here's an example
68  * resource list indicating these assumptions:
69  *
70  * Resource             Index
71  * --------             -----
72  * I/O Port             0
73  * Start DPF            -
74  * IRQ                  1
75  * MemIO                2
76  * Start DPF            -
77  * IRQ                  1
78  * MemIO                2
79  * End DPF              -
80  * DMA Channel          3
81  *
82  * The XXX is because I'm not sure if this is a valid assumption to make.
83  */
84
85 /* States during DPF processing. */
86 #define DPF_OUTSIDE     0
87 #define DPF_FIRST       1
88 #define DPF_IGNORE      2
89
90 struct link;
91
92 struct acpi_pci_link_softc {
93         int     pl_num_links;
94         int     pl_crs_bad;
95         struct link *pl_links;
96         device_t pl_dev;
97 };
98
99 struct link {
100         struct acpi_pci_link_softc *l_sc;
101         uint8_t l_bios_irq;
102         uint8_t l_irq;
103         uint8_t l_initial_irq;
104         int     l_res_index;
105         int     l_num_irqs;
106         int     *l_irqs;
107         int     l_references;
108         int     l_routed:1;
109         int     l_isa_irq:1;
110         ACPI_RESOURCE l_prs_template;
111 };
112
113 struct link_count_request {
114         int     in_dpf;
115         int     count;
116 };
117
118 struct link_res_request {
119         struct acpi_pci_link_softc *sc;
120         int     in_dpf;
121         int     res_index;
122         int     link_index;
123 };
124
125 MALLOC_DEFINE(M_PCI_LINK, "pci_link", "ACPI PCI Link structures");
126
127 static int pci_link_interrupt_weights[NUM_ACPI_INTERRUPTS];
128 static int pci_link_bios_isa_irqs;
129
130 static char *pci_link_ids[] = { "PNP0C0F", NULL };
131
132 /*
133  * Fetch the short name associated with an ACPI handle and save it in the
134  * passed in buffer.
135  */
136 static ACPI_STATUS
137 acpi_short_name(ACPI_HANDLE handle, char *buffer, size_t buflen)
138 {
139         ACPI_BUFFER buf;
140
141         buf.Length = buflen;
142         buf.Pointer = buffer;
143         return (AcpiGetName(handle, ACPI_SINGLE_NAME, &buf));
144 }
145
146 static int
147 acpi_pci_link_probe(device_t dev)
148 {
149         char descr[28], name[12];
150
151         /*
152          * We explicitly do not check _STA since not all systems set it to
153          * sensible values.
154          */
155         if (acpi_disabled("pci_link") ||
156             ACPI_ID_PROBE(device_get_parent(dev), dev, pci_link_ids) == NULL)
157                 return (ENXIO);
158
159         if (ACPI_SUCCESS(acpi_short_name(acpi_get_handle(dev), name,
160             sizeof(name)))) {
161                 ksnprintf(descr, sizeof(descr), "ACPI PCI Link %s", name);
162                 device_set_desc_copy(dev, descr);
163         } else
164                 device_set_desc(dev, "ACPI PCI Link");
165         device_quiet(dev);
166         return (0);
167 }
168
169 static ACPI_STATUS
170 acpi_count_irq_resources(ACPI_RESOURCE *res, void *context)
171 {
172         struct link_count_request *req;
173
174         req = (struct link_count_request *)context;
175         switch (res->Type) {
176         case ACPI_RESOURCE_TYPE_START_DEPENDENT:
177                 switch (req->in_dpf) {
178                 case DPF_OUTSIDE:
179                         /* We've started the first DPF. */
180                         req->in_dpf = DPF_FIRST;
181                         break;
182                 case DPF_FIRST:
183                         /* We've started the second DPF. */
184                         req->in_dpf = DPF_IGNORE;
185                         break;
186                 }
187                 break;
188         case ACPI_RESOURCE_TYPE_END_DEPENDENT:
189                 /* We are finished with DPF parsing. */
190                 KASSERT(req->in_dpf != DPF_OUTSIDE,
191                     ("%s: end dpf when not parsing a dpf", __func__));
192                 req->in_dpf = DPF_OUTSIDE;
193                 break;
194         case ACPI_RESOURCE_TYPE_IRQ:
195         case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
196                 /*
197                  * Don't count resources if we are in a DPF set that we are
198                  * ignoring.
199                  */
200                 if (req->in_dpf != DPF_IGNORE)
201                         req->count++;
202         }
203         return (AE_OK);
204 }
205
206 static ACPI_STATUS
207 link_add_crs(ACPI_RESOURCE *res, void *context)
208 {
209         struct link_res_request *req;
210         struct link *link;
211
212         ACPI_SERIAL_ASSERT(pci_link);
213         req = (struct link_res_request *)context;
214         switch (res->Type) {
215         case ACPI_RESOURCE_TYPE_START_DEPENDENT:
216                 switch (req->in_dpf) {
217                 case DPF_OUTSIDE:
218                         /* We've started the first DPF. */
219                         req->in_dpf = DPF_FIRST;
220                         break;
221                 case DPF_FIRST:
222                         /* We've started the second DPF. */
223                         panic(
224                 "%s: Multiple dependent functions within a current resource",
225                             __func__);
226                         break;
227                 }
228                 break;
229         case ACPI_RESOURCE_TYPE_END_DEPENDENT:
230                 /* We are finished with DPF parsing. */
231                 KASSERT(req->in_dpf != DPF_OUTSIDE,
232                     ("%s: end dpf when not parsing a dpf", __func__));
233                 req->in_dpf = DPF_OUTSIDE;
234                 break;
235         case ACPI_RESOURCE_TYPE_IRQ:
236         case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
237                 KASSERT(req->link_index < req->sc->pl_num_links,
238                     ("%s: array boundary violation", __func__));
239                 link = &req->sc->pl_links[req->link_index];
240                 link->l_res_index = req->res_index;
241                 req->link_index++;
242                 req->res_index++;
243
244                 /*
245                  * Only use the current value if there's one IRQ.  Some
246                  * systems return multiple IRQs (which is nonsense for _CRS)
247                  * when the link hasn't been programmed.
248                  */
249                 if (res->Type == ACPI_RESOURCE_TYPE_IRQ) {
250                         if (res->Data.Irq.InterruptCount == 1)
251                                 link->l_irq = res->Data.Irq.Interrupts[0];
252                 } else if (res->Data.ExtendedIrq.InterruptCount == 1)
253                         link->l_irq = res->Data.ExtendedIrq.Interrupts[0];
254
255                 /*
256                  * An IRQ of zero means that the link isn't routed.
257                  */
258                 if (link->l_irq == 0)
259                         link->l_irq = PCI_INVALID_IRQ;
260                 break;
261         default:
262                 req->res_index++;
263         }
264         return (AE_OK);
265 }
266
267 /*
268  * Populate the set of possible IRQs for each device.
269  */
270 static ACPI_STATUS
271 link_add_prs(ACPI_RESOURCE *res, void *context)
272 {
273         struct link_res_request *req;
274         struct link *link;
275         UINT8 *irqs = NULL;
276         UINT32 *ext_irqs = NULL;
277         int i, is_ext_irq = 1;
278
279         ACPI_SERIAL_ASSERT(pci_link);
280         req = (struct link_res_request *)context;
281         switch (res->Type) {
282         case ACPI_RESOURCE_TYPE_START_DEPENDENT:
283                 switch (req->in_dpf) {
284                 case DPF_OUTSIDE:
285                         /* We've started the first DPF. */
286                         req->in_dpf = DPF_FIRST;
287                         break;
288                 case DPF_FIRST:
289                         /* We've started the second DPF. */
290                         req->in_dpf = DPF_IGNORE;
291                         break;
292                 }
293                 break;
294         case ACPI_RESOURCE_TYPE_END_DEPENDENT:
295                 /* We are finished with DPF parsing. */
296                 KASSERT(req->in_dpf != DPF_OUTSIDE,
297                     ("%s: end dpf when not parsing a dpf", __func__));
298                 req->in_dpf = DPF_OUTSIDE;
299                 break;
300         case ACPI_RESOURCE_TYPE_IRQ:
301                 is_ext_irq = 0;
302                 /* fall through */
303         case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
304                 /*
305                  * Don't parse resources if we are in a DPF set that we are
306                  * ignoring.
307                  */
308                 if (req->in_dpf == DPF_IGNORE)
309                         break;
310
311                 KASSERT(req->link_index < req->sc->pl_num_links,
312                     ("%s: array boundary violation", __func__));
313                 link = &req->sc->pl_links[req->link_index];
314                 if (link->l_res_index == -1) {
315                         KASSERT(req->sc->pl_crs_bad,
316                             ("res_index should be set"));
317                         link->l_res_index = req->res_index;
318                 }
319                 req->link_index++;
320                 req->res_index++;
321
322                 /*
323                  * Stash a copy of the resource for later use when doing
324                  * _SRS.
325                  */
326                 bcopy(res, &link->l_prs_template, sizeof(ACPI_RESOURCE));
327                 if (is_ext_irq) {
328                         link->l_num_irqs =
329                             res->Data.ExtendedIrq.InterruptCount;
330                         ext_irqs = res->Data.ExtendedIrq.Interrupts;
331                 } else {
332                         link->l_num_irqs = res->Data.Irq.InterruptCount;
333                         irqs = res->Data.Irq.Interrupts;
334                 }
335                 if (link->l_num_irqs == 0)
336                         break;
337
338                 /*
339                  * Save a list of the valid IRQs.  Also, if all of the
340                  * valid IRQs are ISA IRQs, then mark this link as
341                  * routed via an ISA interrupt.
342                  */
343                 link->l_isa_irq = TRUE;
344
345                 link->l_irqs = kmalloc(sizeof(int) * link->l_num_irqs,
346                     M_PCI_LINK, M_WAITOK | M_ZERO);
347                 for (i = 0; i < link->l_num_irqs; i++) {
348                         if (is_ext_irq) {
349                                 link->l_irqs[i] = ext_irqs[i];
350                                 if (ext_irqs[i] >= NUM_ISA_INTERRUPTS)
351                                         link->l_isa_irq = FALSE;
352                         } else {
353                                 link->l_irqs[i] = irqs[i];
354                                 if (irqs[i] >= NUM_ISA_INTERRUPTS)
355                                         link->l_isa_irq = FALSE;
356                         }
357                 }
358                 break;
359         default:
360                 if (req->in_dpf == DPF_IGNORE)
361                         break;
362                 if (req->sc->pl_crs_bad)
363                         device_printf(req->sc->pl_dev,
364                     "Warning: possible resource %d will be lost during _SRS\n",
365                             req->res_index);
366                 req->res_index++;
367         }
368         return (AE_OK);
369 }
370
371 static int
372 link_valid_irq(struct link *link, int irq)
373 {
374         int i;
375
376         ACPI_SERIAL_ASSERT(pci_link);
377
378         /* Invalid interrupts are never valid. */
379         if (!PCI_INTERRUPT_VALID(irq))
380                 return (FALSE);
381
382         /* Any interrupt in the list of possible interrupts is valid. */
383         for (i = 0; i < link->l_num_irqs; i++)
384                 if (link->l_irqs[i] == irq)
385                          return (TRUE);
386
387         /*
388          * For links routed via an ISA interrupt, if the SCI is routed via
389          * an ISA interrupt, the SCI is always treated as a valid IRQ.
390          */
391         if (link->l_isa_irq && AcpiGbl_FADT.SciInterrupt == irq &&
392             irq < NUM_ISA_INTERRUPTS)
393                 return (TRUE);
394
395         /* If the interrupt wasn't found in the list it is not valid. */
396         return (FALSE);
397 }
398
399 static void
400 acpi_pci_link_dump(struct acpi_pci_link_softc *sc, int header, const char *tag)
401 {
402         struct link *link;
403         char buf[16];
404         int i, j;
405
406         ACPI_SERIAL_ASSERT(pci_link);
407         if (header) {
408                 ksnprintf(buf, sizeof(buf), "%s:",
409                     device_get_nameunit(sc->pl_dev));
410                 kprintf("%-16.16s  Index  IRQ  Rtd  Ref  IRQs\n", buf);
411         }
412         for (i = 0; i < sc->pl_num_links; i++) {
413                 link = &sc->pl_links[i];
414                 kprintf("  %-14.14s  %5d  %3d   %c   %3d ", i == 0 ? tag : "", i,
415                     link->l_irq, link->l_routed ? 'Y' : 'N',
416                     link->l_references);
417                 if (link->l_num_irqs == 0)
418                         kprintf(" none");
419                 else for (j = 0; j < link->l_num_irqs; j++)
420                         kprintf(" %d", link->l_irqs[j]);
421                 kprintf("\n");
422         }
423 }
424
425 static int
426 acpi_pci_link_attach(device_t dev)
427 {
428         struct acpi_pci_link_softc *sc;
429         struct link_count_request creq;
430         struct link_res_request rreq;
431         ACPI_STATUS status;
432         int i;
433
434         sc = device_get_softc(dev);
435         sc->pl_dev = dev;
436         ACPI_SERIAL_INIT(pci_link);
437         ACPI_SERIAL_BEGIN(pci_link);
438
439         /*
440          * Count the number of current resources so we know how big of
441          * a link array to allocate.  On some systems, _CRS is broken,
442          * so for those systems try to derive the count from _PRS instead.
443          */
444         creq.in_dpf = DPF_OUTSIDE;
445         creq.count = 0;
446         status = AcpiWalkResources(acpi_get_handle(dev), "_CRS",
447             acpi_count_irq_resources, &creq);
448         sc->pl_crs_bad = ACPI_FAILURE(status);
449         if (sc->pl_crs_bad) {
450                 creq.in_dpf = DPF_OUTSIDE;
451                 creq.count = 0;
452                 status = AcpiWalkResources(acpi_get_handle(dev), "_PRS",
453                     acpi_count_irq_resources, &creq);
454                 if (ACPI_FAILURE(status)) {
455                         device_printf(dev,
456                             "Unable to parse _CRS or _PRS: %s\n",
457                             AcpiFormatException(status));
458                         ACPI_SERIAL_END(pci_link);
459                         return (ENXIO);
460                 }
461         }
462         sc->pl_num_links = creq.count;
463         if (creq.count == 0) {
464                 ACPI_SERIAL_END(pci_link);
465                 return (0);
466         }
467         sc->pl_links = kmalloc(sizeof(struct link) * sc->pl_num_links,
468             M_PCI_LINK, M_WAITOK | M_ZERO);
469
470         /* Initialize the child links. */
471         for (i = 0; i < sc->pl_num_links; i++) {
472                 sc->pl_links[i].l_irq = PCI_INVALID_IRQ;
473                 sc->pl_links[i].l_bios_irq = PCI_INVALID_IRQ;
474                 sc->pl_links[i].l_sc = sc;
475                 sc->pl_links[i].l_isa_irq = FALSE;
476                 sc->pl_links[i].l_res_index = -1;
477         }
478
479         /* Try to read the current settings from _CRS if it is valid. */
480         if (!sc->pl_crs_bad) {
481                 rreq.in_dpf = DPF_OUTSIDE;
482                 rreq.link_index = 0;
483                 rreq.res_index = 0;
484                 rreq.sc = sc;
485                 status = AcpiWalkResources(acpi_get_handle(dev), "_CRS",
486                     link_add_crs, &rreq);
487                 if (ACPI_FAILURE(status)) {
488                         device_printf(dev, "Unable to parse _CRS: %s\n",
489                             AcpiFormatException(status));
490                         goto fail;
491                 }
492         }
493
494         /*
495          * Try to read the possible settings from _PRS.  Note that if the
496          * _CRS is toast, we depend on having a working _PRS.  However, if
497          * _CRS works, then it is ok for _PRS to be missing.
498          */
499         rreq.in_dpf = DPF_OUTSIDE;
500         rreq.link_index = 0;
501         rreq.res_index = 0;
502         rreq.sc = sc;
503         status = AcpiWalkResources(acpi_get_handle(dev), "_PRS",
504             link_add_prs, &rreq);
505         if (ACPI_FAILURE(status) &&
506             (status != AE_NOT_FOUND || sc->pl_crs_bad)) {
507                 device_printf(dev, "Unable to parse _PRS: %s\n",
508                     AcpiFormatException(status));
509                 goto fail;
510         }
511         if (bootverbose)
512                 acpi_pci_link_dump(sc, 1, "Initial Probe");
513
514         /* Verify initial IRQs if we have _PRS. */
515         if (status != AE_NOT_FOUND)
516                 for (i = 0; i < sc->pl_num_links; i++)
517                         if (!link_valid_irq(&sc->pl_links[i],
518                             sc->pl_links[i].l_irq))
519                                 sc->pl_links[i].l_irq = PCI_INVALID_IRQ;
520         if (bootverbose)
521                 acpi_pci_link_dump(sc, 0, "Validation");
522
523         /* Save initial IRQs. */
524         for (i = 0; i < sc->pl_num_links; i++)
525                 sc->pl_links[i].l_initial_irq = sc->pl_links[i].l_irq;
526
527         /*
528          * Try to disable this link.  If successful, set the current IRQ to
529          * zero and flags to indicate this link is not routed.  If we can't
530          * run _DIS (i.e., the method doesn't exist), assume the initial
531          * IRQ was routed by the BIOS.
532          */
533         if (ACPI_SUCCESS(AcpiEvaluateObject(acpi_get_handle(dev), "_DIS", NULL,
534             NULL)))
535                 for (i = 0; i < sc->pl_num_links; i++)
536                         sc->pl_links[i].l_irq = PCI_INVALID_IRQ;
537         else
538                 for (i = 0; i < sc->pl_num_links; i++)
539                         if (PCI_INTERRUPT_VALID(sc->pl_links[i].l_irq))
540                                 sc->pl_links[i].l_routed = TRUE;
541         if (bootverbose)
542                 acpi_pci_link_dump(sc, 0, "After Disable");
543         ACPI_SERIAL_END(pci_link);
544         return (0);
545 fail:
546         ACPI_SERIAL_END(pci_link);
547         for (i = 0; i < sc->pl_num_links; i++)
548                 if (sc->pl_links[i].l_irqs != NULL)
549                         kfree(sc->pl_links[i].l_irqs, M_PCI_LINK);
550         kfree(sc->pl_links, M_PCI_LINK);
551         return (ENXIO);
552 }
553
554 /* XXX: Note that this is identical to pci_pir_search_irq(). */
555 static uint8_t
556 acpi_pci_link_search_irq(int bus, int device, int pin)
557 {
558         uint32_t value;
559         uint8_t func, maxfunc;
560
561         /* See if we have a valid device at function 0. */
562         value = pci_cfgregread(bus, device, 0, PCIR_HDRTYPE, 1);
563         if ((value & PCIM_HDRTYPE) > PCI_MAXHDRTYPE)
564                 return (PCI_INVALID_IRQ);
565         if (value & PCIM_MFDEV)
566                 maxfunc = PCI_FUNCMAX;
567         else
568                 maxfunc = 0;
569
570         /* Scan all possible functions at this device. */
571         for (func = 0; func <= maxfunc; func++) {
572                 value = pci_cfgregread(bus, device, func, PCIR_DEVVENDOR, 4);
573                 if (value == 0xffffffff)
574                         continue;
575                 value = pci_cfgregread(bus, device, func, PCIR_INTPIN, 1);
576
577                 /*
578                  * See if it uses the pin in question.  Note that the passed
579                  * in pin uses 0 for A, .. 3 for D whereas the intpin
580                  * register uses 0 for no interrupt, 1 for A, .. 4 for D.
581                  */
582                 if (value != pin + 1)
583                         continue;
584                 value = pci_cfgregread(bus, device, func, PCIR_INTLINE, 1);
585                 if (bootverbose)
586                         kprintf(
587                 "ACPI: Found matching pin for %d.%d.INT%c at func %d: %d\n",
588                             bus, device, pin + 'A', func, value);
589                 if (value != PCI_INVALID_IRQ)
590                         return (value);
591         }
592         return (PCI_INVALID_IRQ);
593 }
594
595 /*
596  * Find the link structure that corresponds to the resource index passed in
597  * via 'source_index'.
598  */
599 static struct link *
600 acpi_pci_link_lookup(device_t dev, int source_index)
601 {
602         struct acpi_pci_link_softc *sc;
603         int i;
604
605         ACPI_SERIAL_ASSERT(pci_link);
606         sc = device_get_softc(dev);
607         for (i = 0; i < sc->pl_num_links; i++)
608                 if (sc->pl_links[i].l_res_index == source_index)
609                         return (&sc->pl_links[i]);
610         return (NULL);
611 }
612
613 void
614 acpi_pci_link_add_reference(device_t dev, int index, device_t pcib, int slot,
615     int pin)
616 {
617         struct link *link;
618         uint8_t bios_irq;
619         uintptr_t bus;
620
621         /*
622          * Look up the PCI bus for the specified PCI bridge device.  Note
623          * that the PCI bridge device might not have any children yet.
624          * However, looking up its bus number doesn't require a valid child
625          * device, so we just pass NULL.
626          */
627         if (BUS_READ_IVAR(pcib, NULL, PCIB_IVAR_BUS, &bus) != 0) {
628                 device_printf(pcib, "Unable to read PCI bus number");
629                 panic("PCI bridge without a bus number");
630         }
631
632         /* Bump the reference count. */
633         ACPI_SERIAL_BEGIN(pci_link);
634         link = acpi_pci_link_lookup(dev, index);
635         if (link == NULL) {
636                 device_printf(dev, "apparently invalid index %d\n", index);
637                 ACPI_SERIAL_END(pci_link);
638                 return;
639         }
640         link->l_references++;
641         if (link->l_routed)
642                 pci_link_interrupt_weights[link->l_irq]++;
643
644         /*
645          * The BIOS only routes interrupts via ISA IRQs using the ATPICs
646          * (8259As).  Thus, if this link is routed via an ISA IRQ, go
647          * look to see if the BIOS routed an IRQ for this link at the
648          * indicated (bus, slot, pin).  If so, we prefer that IRQ for
649          * this link and add that IRQ to our list of known-good IRQs.
650          * This provides a good work-around for link devices whose _CRS
651          * method is either broken or bogus.  We only use the value
652          * returned by _CRS if we can't find a valid IRQ via this method
653          * in fact.
654          *
655          * If this link is not routed via an ISA IRQ (because we are using
656          * APIC for example), then don't bother looking up the BIOS IRQ
657          * as if we find one it won't be valid anyway.
658          */
659         if (!link->l_isa_irq) {
660                 ACPI_SERIAL_END(pci_link);
661                 return;
662         }
663
664         /* Try to find a BIOS IRQ setting from any matching devices. */
665         bios_irq = acpi_pci_link_search_irq(bus, slot, pin);
666         if (!PCI_INTERRUPT_VALID(bios_irq)) {
667                 ACPI_SERIAL_END(pci_link);
668                 return;
669         }
670
671         /* Validate the BIOS IRQ. */
672         if (!link_valid_irq(link, bios_irq)) {
673                 device_printf(dev, "BIOS IRQ %u for %d.%d.INT%c is invalid\n",
674                     bios_irq, (int)bus, slot, pin + 'A');
675         } else if (!PCI_INTERRUPT_VALID(link->l_bios_irq)) {
676                 link->l_bios_irq = bios_irq;
677                 /*
678                  * Avoid sharing interrupt with SCI if possible,
679                  * since ACPI interrupt handler is generally time
680                  * consuming.
681                  */
682                 if (bios_irq < NUM_ISA_INTERRUPTS &&
683                     AcpiGbl_FADT.SciInterrupt != bios_irq)
684                         pci_link_bios_isa_irqs |= (1 << bios_irq);
685                 if (bios_irq != link->l_initial_irq &&
686                     PCI_INTERRUPT_VALID(link->l_initial_irq))
687                         device_printf(dev,
688                             "BIOS IRQ %u does not match initial IRQ %u\n",
689                             bios_irq, link->l_initial_irq);
690         } else if (bios_irq != link->l_bios_irq)
691                 device_printf(dev,
692             "BIOS IRQ %u for %d.%d.INT%c does not match previous BIOS IRQ %u\n",
693                     bios_irq, (int)bus, slot, pin + 'A',
694                     link->l_bios_irq);
695         ACPI_SERIAL_END(pci_link);
696 }
697
698 static ACPI_STATUS
699 acpi_pci_link_srs_from_crs(struct acpi_pci_link_softc *sc, ACPI_BUFFER *srsbuf)
700 {
701         ACPI_RESOURCE *resource, *end, newres, *resptr;
702         ACPI_BUFFER crsbuf;
703         ACPI_STATUS status;
704         struct link *link;
705         int i, in_dpf;
706
707         /* Fetch the _CRS. */
708         ACPI_SERIAL_ASSERT(pci_link);
709         crsbuf.Pointer = NULL;
710         crsbuf.Length = ACPI_ALLOCATE_BUFFER;
711         status = AcpiGetCurrentResources(acpi_get_handle(sc->pl_dev), &crsbuf);
712         if (ACPI_SUCCESS(status) && crsbuf.Pointer == NULL)
713                 status = AE_NO_MEMORY;
714         if (ACPI_FAILURE(status)) {
715                 if (bootverbose)
716                         device_printf(sc->pl_dev,
717                             "Unable to fetch current resources: %s\n",
718                             AcpiFormatException(status));
719                 return (status);
720         }
721
722         /* Fill in IRQ resources via link structures. */
723         srsbuf->Pointer = NULL;
724         link = sc->pl_links;
725         i = 0;
726         in_dpf = DPF_OUTSIDE;
727         resource = (ACPI_RESOURCE *)crsbuf.Pointer;
728         end = (ACPI_RESOURCE *)((char *)crsbuf.Pointer + crsbuf.Length);
729         for (;;) {
730                 switch (resource->Type) {
731                 case ACPI_RESOURCE_TYPE_START_DEPENDENT:
732                         switch (in_dpf) {
733                         case DPF_OUTSIDE:
734                                 /* We've started the first DPF. */
735                                 in_dpf = DPF_FIRST;
736                                 break;
737                         case DPF_FIRST:
738                                 /* We've started the second DPF. */
739                                 panic(
740                 "%s: Multiple dependent functions within a current resource",
741                                     __func__);
742                                 break;
743                         }
744                         resptr = NULL;
745                         break;
746                 case ACPI_RESOURCE_TYPE_END_DEPENDENT:
747                         /* We are finished with DPF parsing. */
748                         KASSERT(in_dpf != DPF_OUTSIDE,
749                             ("%s: end dpf when not parsing a dpf", __func__));
750                         in_dpf = DPF_OUTSIDE;
751                         resptr = NULL;
752                         break;
753                 case ACPI_RESOURCE_TYPE_IRQ:
754                         MPASS(i < sc->pl_num_links);
755                         MPASS(link->l_prs_template.Type == ACPI_RESOURCE_TYPE_IRQ);
756                         newres = link->l_prs_template;
757                         resptr = &newres;
758                         resptr->Data.Irq.InterruptCount = 1;
759                         if (PCI_INTERRUPT_VALID(link->l_irq)) {
760                                 KASSERT(link->l_irq < NUM_ISA_INTERRUPTS,
761                 ("%s: can't put non-ISA IRQ %d in legacy IRQ resource type",
762                                     __func__, link->l_irq));
763                                 resptr->Data.Irq.Interrupts[0] = link->l_irq;
764                         } else
765                                 resptr->Data.Irq.Interrupts[0] = 0;
766                         link++;
767                         i++;
768                         break;
769                 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
770                         MPASS(i < sc->pl_num_links);
771                         MPASS(link->l_prs_template.Type == ACPI_RESOURCE_TYPE_EXTENDED_IRQ);
772                         newres = link->l_prs_template;
773                         resptr = &newres;
774                         resptr->Data.ExtendedIrq.InterruptCount = 1;
775                         if (PCI_INTERRUPT_VALID(link->l_irq))
776                                 resptr->Data.ExtendedIrq.Interrupts[0] =
777                                     link->l_irq;
778                         else
779                                 resptr->Data.ExtendedIrq.Interrupts[0] = 0;
780                         link++;
781                         i++;
782                         break;
783                 default:
784                         resptr = resource;
785                 }
786                 if (resptr != NULL) {
787                         status = acpi_AppendBufferResource(srsbuf, resptr);
788                         if (ACPI_FAILURE(status)) {
789                                 device_printf(sc->pl_dev,
790                                     "Unable to build resources: %s\n",
791                                     AcpiFormatException(status));
792                                 if (srsbuf->Pointer != NULL)
793                                         AcpiOsFree(srsbuf->Pointer);
794                                 AcpiOsFree(crsbuf.Pointer);
795                                 return (status);
796                         }
797                 }
798                 if (resource->Type == ACPI_RESOURCE_TYPE_END_TAG)
799                         break;
800                 resource = ACPI_NEXT_RESOURCE(resource);
801                 if (resource >= end)
802                         break;
803         }
804         AcpiOsFree(crsbuf.Pointer);
805         return (AE_OK);
806 }
807
808 static ACPI_STATUS
809 acpi_pci_link_srs_from_links(struct acpi_pci_link_softc *sc,
810     ACPI_BUFFER *srsbuf)
811 {
812         ACPI_RESOURCE newres;
813         ACPI_STATUS status;
814         struct link *link;
815         int i;
816
817         /* Start off with an empty buffer. */
818         srsbuf->Pointer = NULL;
819         link = sc->pl_links;
820         for (i = 0; i < sc->pl_num_links; i++) {
821
822                 /* Add a new IRQ resource from each link. */
823                 link = &sc->pl_links[i];
824                 newres = link->l_prs_template;
825                 if (newres.Type == ACPI_RESOURCE_TYPE_IRQ) {
826
827                         /* Build an IRQ resource. */
828                         newres.Data.Irq.InterruptCount = 1;
829                         if (PCI_INTERRUPT_VALID(link->l_irq)) {
830                                 KASSERT(link->l_irq < NUM_ISA_INTERRUPTS,
831                 ("%s: can't put non-ISA IRQ %d in legacy IRQ resource type",
832                                     __func__, link->l_irq));
833                                 newres.Data.Irq.Interrupts[0] = link->l_irq;
834                         } else
835                                 newres.Data.Irq.Interrupts[0] = 0;
836                 } else {
837
838                         /* Build an ExtIRQ resuorce. */
839                         newres.Data.ExtendedIrq.InterruptCount = 1;
840                         if (PCI_INTERRUPT_VALID(link->l_irq))
841                                 newres.Data.ExtendedIrq.Interrupts[0] =
842                                     link->l_irq;
843                         else
844                                 newres.Data.ExtendedIrq.Interrupts[0] = 0;
845                 }
846
847                 /* Add the new resource to the end of the _SRS buffer. */
848                 status = acpi_AppendBufferResource(srsbuf, &newres);
849                 if (ACPI_FAILURE(status)) {
850                         device_printf(sc->pl_dev,
851                             "Unable to build resources: %s\n",
852                             AcpiFormatException(status));
853                         if (srsbuf->Pointer != NULL)
854                                 AcpiOsFree(srsbuf->Pointer);
855                         return (status);
856                 }
857         }
858         return (AE_OK);
859 }
860
861 static ACPI_STATUS
862 acpi_pci_link_route_irqs(device_t dev)
863 {
864         struct acpi_pci_link_softc *sc;
865         ACPI_RESOURCE *resource, *end;
866         ACPI_BUFFER srsbuf;
867         ACPI_STATUS status;
868         struct link *link;
869         int i;
870
871         ACPI_SERIAL_ASSERT(pci_link);
872         sc = device_get_softc(dev);
873         if (sc->pl_crs_bad)
874                 status = acpi_pci_link_srs_from_links(sc, &srsbuf);
875         else
876                 status = acpi_pci_link_srs_from_crs(sc, &srsbuf);
877
878         /* Write out new resources via _SRS. */
879         status = AcpiSetCurrentResources(acpi_get_handle(dev), &srsbuf);
880         if (ACPI_FAILURE(status)) {
881                 device_printf(dev, "Unable to route IRQs: %s\n",
882                     AcpiFormatException(status));
883                 AcpiOsFree(srsbuf.Pointer);
884                 return (status);
885         }
886
887         /*
888          * Perform acpi_config_intr() on each IRQ resource if it was just
889          * routed for the first time.
890          */
891         link = sc->pl_links;
892         i = 0;
893         resource = (ACPI_RESOURCE *)srsbuf.Pointer;
894         end = (ACPI_RESOURCE *)((char *)srsbuf.Pointer + srsbuf.Length);
895         for (;;) {
896                 if (resource->Type == ACPI_RESOURCE_TYPE_END_TAG)
897                         break;
898                 switch (resource->Type) {
899                 case ACPI_RESOURCE_TYPE_IRQ:
900                 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
901                         MPASS(i < sc->pl_num_links);
902
903                         /*
904                          * Only configure the interrupt and update the
905                          * weights if this link has a valid IRQ and was
906                          * previously unrouted.
907                          */
908                         if (!link->l_routed &&
909                             PCI_INTERRUPT_VALID(link->l_irq)) {
910                                 link->l_routed = TRUE;
911                                 acpi_config_intr(dev, resource);
912                                 pci_link_interrupt_weights[link->l_irq] +=
913                                     link->l_references;
914                         }
915                         link++;
916                         i++;
917                         break;
918                 }
919                 resource = ACPI_NEXT_RESOURCE(resource);
920                 if (resource >= end)
921                         break;
922         }
923         AcpiOsFree(srsbuf.Pointer);
924         return (AE_OK);
925 }
926
927 static int
928 acpi_pci_link_resume(device_t dev)
929 {
930         struct acpi_pci_link_softc *sc;
931         ACPI_STATUS status;
932         int i, routed;
933
934         /*
935          * If all of our links are routed, then restore the link via _SRS,
936          * otherwise, disable the link via _DIS.
937          */
938         ACPI_SERIAL_BEGIN(pci_link);
939         sc = device_get_softc(dev);
940         routed = 0;
941         for (i = 0; i < sc->pl_num_links; i++)
942                 if (sc->pl_links[i].l_routed)
943                         routed++;
944         if (routed == sc->pl_num_links)
945                 status = acpi_pci_link_route_irqs(dev);
946         else {
947                 AcpiEvaluateObject(acpi_get_handle(dev), "_DIS", NULL, NULL);
948                 status = AE_OK;
949         }
950         ACPI_SERIAL_END(pci_link);
951         if (ACPI_FAILURE(status))
952                 return (ENXIO);
953         else
954                 return (0);
955 }
956
957 /*
958  * Pick an IRQ to use for this unrouted link.
959  */
960 static uint8_t
961 acpi_pci_link_choose_irq(device_t dev, struct link *link)
962 {
963         char tunable_buffer[64], link_name[5];
964         u_int8_t best_irq, pos_irq;
965         int best_weight, pos_weight, i;
966
967         KASSERT(!link->l_routed, ("%s: link already routed", __func__));
968         KASSERT(!PCI_INTERRUPT_VALID(link->l_irq),
969             ("%s: link already has an IRQ", __func__));
970
971         /* Check for a tunable override. */
972         if (ACPI_SUCCESS(acpi_short_name(acpi_get_handle(dev), link_name,
973             sizeof(link_name)))) {
974                 ksnprintf(tunable_buffer, sizeof(tunable_buffer),
975                     "hw.pci.link.%s.%d.irq", link_name, link->l_res_index);
976                 if (kgetenv_int(tunable_buffer, &i) && PCI_INTERRUPT_VALID(i)) {
977                         if (!link_valid_irq(link, i))
978                                 device_printf(dev,
979                                     "Warning, IRQ %d is not listed as valid\n",
980                                     i);
981                         return (i);
982                 }
983                 ksnprintf(tunable_buffer, sizeof(tunable_buffer),
984                     "hw.pci.link.%s.irq", link_name);
985                 if (kgetenv_int(tunable_buffer, &i) && PCI_INTERRUPT_VALID(i)) {
986                         if (!link_valid_irq(link, i))
987                                 device_printf(dev,
988                                     "Warning, IRQ %d is not listed as valid\n",
989                                     i);
990                         return (i);
991                 }
992         }
993
994         /*
995          * If we have a valid BIOS IRQ, use that.  We trust what the BIOS
996          * says it routed over what _CRS says the link thinks is routed.
997          */
998         if (PCI_INTERRUPT_VALID(link->l_bios_irq))
999                 return (link->l_bios_irq);
1000
1001         /*
1002          * If we don't have a BIOS IRQ but do have a valid IRQ from _CRS,
1003          * then use that.
1004          */
1005         if (PCI_INTERRUPT_VALID(link->l_initial_irq))
1006                 return (link->l_initial_irq);
1007
1008         /*
1009          * Ok, we have no useful hints, so we have to pick from the
1010          * possible IRQs.  For ISA IRQs we only use interrupts that
1011          * have already been used by the BIOS.
1012          */
1013         best_irq = PCI_INVALID_IRQ;
1014         best_weight = INT_MAX;
1015         for (i = 0; i < link->l_num_irqs; i++) {
1016                 pos_irq = link->l_irqs[i];
1017                 if (pos_irq < NUM_ISA_INTERRUPTS &&
1018                     (pci_link_bios_isa_irqs & 1 << pos_irq) == 0)
1019                         continue;
1020                 pos_weight = pci_link_interrupt_weights[pos_irq];
1021                 if (pos_weight < best_weight) {
1022                         best_weight = pos_weight;
1023                         best_irq = pos_irq;
1024                 }
1025         }
1026
1027         /*
1028          * Check SCI as the last resort.
1029          */
1030         if (link->l_isa_irq && !PCI_INTERRUPT_VALID(best_irq)) {
1031                 pos_irq = AcpiGbl_FADT.SciInterrupt;
1032                 pos_weight = pci_link_interrupt_weights[pos_irq];
1033                 if (pos_weight < best_weight) {
1034                         best_weight = pos_weight;
1035                         best_irq = pos_irq;
1036                 }
1037         }
1038
1039         if (PCI_INTERRUPT_VALID(best_irq)) {
1040                 if (bootverbose)
1041                         device_printf(dev, "Picked IRQ %u with weight %d\n",
1042                             best_irq, best_weight);
1043         } else
1044                 device_printf(dev, "Unable to choose an IRQ\n");
1045         return (best_irq);
1046 }
1047
1048 int
1049 acpi_pci_link_route_interrupt(device_t dev, int index)
1050 {
1051         struct link *link;
1052
1053         if (!acpi_enabled("pci_link"))
1054                 return (PCI_INVALID_IRQ);
1055
1056         ACPI_SERIAL_BEGIN(pci_link);
1057         link = acpi_pci_link_lookup(dev, index);
1058         if (link == NULL)
1059                 panic("%s: apparently invalid index %d", __func__, index);
1060
1061         /*
1062          * If this link device is already routed to an interrupt, just return
1063          * the interrupt it is routed to.
1064          */
1065         if (link->l_routed) {
1066                 KASSERT(PCI_INTERRUPT_VALID(link->l_irq),
1067                     ("%s: link is routed but has an invalid IRQ", __func__));
1068                 ACPI_SERIAL_END(pci_link);
1069                 return (link->l_irq);
1070         }
1071
1072         /* Choose an IRQ if we need one. */
1073         if (!PCI_INTERRUPT_VALID(link->l_irq)) {
1074                 link->l_irq = acpi_pci_link_choose_irq(dev, link);
1075
1076                 /*
1077                  * Try to route the interrupt we picked.  If it fails, then
1078                  * assume the interrupt is not routed.
1079                  */
1080                 if (PCI_INTERRUPT_VALID(link->l_irq)) {
1081                         acpi_pci_link_route_irqs(dev);
1082                         if (!link->l_routed)
1083                                 link->l_irq = PCI_INVALID_IRQ;
1084                 }
1085         }
1086         ACPI_SERIAL_END(pci_link);
1087         return (link->l_irq);
1088 }
1089
1090 static device_method_t acpi_pci_link_methods[] = {
1091         /* Device interface */
1092         DEVMETHOD(device_probe,         acpi_pci_link_probe),
1093         DEVMETHOD(device_attach,        acpi_pci_link_attach),
1094         DEVMETHOD(device_resume,        acpi_pci_link_resume),
1095
1096         {0, 0}
1097 };
1098
1099 static driver_t acpi_pci_link_driver = {
1100         "pci_link",
1101         acpi_pci_link_methods,
1102         sizeof(struct acpi_pci_link_softc),
1103 };
1104
1105 static devclass_t pci_link_devclass;
1106
1107 DRIVER_MODULE(acpi_pci_link, acpi, acpi_pci_link_driver, pci_link_devclass, 0,
1108     0);
1109 MODULE_DEPEND(acpi_pci_link, acpi, 1, 1, 1);