Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : * pci_link.c - ACPI PCI Interrupt Link Device Driver ($Revision: 34 $)
4 : : *
5 : : * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
6 : : * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
7 : : * Copyright (C) 2002 Dominik Brodowski <devel@brodo.de>
8 : : *
9 : : * TBD:
10 : : * 1. Support more than one IRQ resource entry per link device (index).
11 : : * 2. Implement start/stop mechanism and use ACPI Bus Driver facilities
12 : : * for IRQ management (e.g. start()->_SRS).
13 : : */
14 : :
15 : : #include <linux/syscore_ops.h>
16 : : #include <linux/kernel.h>
17 : : #include <linux/module.h>
18 : : #include <linux/init.h>
19 : : #include <linux/types.h>
20 : : #include <linux/spinlock.h>
21 : : #include <linux/pm.h>
22 : : #include <linux/pci.h>
23 : : #include <linux/mutex.h>
24 : : #include <linux/slab.h>
25 : : #include <linux/acpi.h>
26 : : #include <linux/irq.h>
27 : :
28 : : #include "internal.h"
29 : :
30 : : #define _COMPONENT ACPI_PCI_COMPONENT
31 : : ACPI_MODULE_NAME("pci_link");
32 : : #define ACPI_PCI_LINK_CLASS "pci_irq_routing"
33 : : #define ACPI_PCI_LINK_DEVICE_NAME "PCI Interrupt Link"
34 : : #define ACPI_PCI_LINK_FILE_INFO "info"
35 : : #define ACPI_PCI_LINK_FILE_STATUS "state"
36 : : #define ACPI_PCI_LINK_MAX_POSSIBLE 16
37 : :
38 : : static int acpi_pci_link_add(struct acpi_device *device,
39 : : const struct acpi_device_id *not_used);
40 : : static void acpi_pci_link_remove(struct acpi_device *device);
41 : :
42 : : static const struct acpi_device_id link_device_ids[] = {
43 : : {"PNP0C0F", 0},
44 : : {"", 0},
45 : : };
46 : :
47 : : static struct acpi_scan_handler pci_link_handler = {
48 : : .ids = link_device_ids,
49 : : .attach = acpi_pci_link_add,
50 : : .detach = acpi_pci_link_remove,
51 : : };
52 : :
53 : : /*
54 : : * If a link is initialized, we never change its active and initialized
55 : : * later even the link is disable. Instead, we just repick the active irq
56 : : */
57 : : struct acpi_pci_link_irq {
58 : : u32 active; /* Current IRQ */
59 : : u8 triggering; /* All IRQs */
60 : : u8 polarity; /* All IRQs */
61 : : u8 resource_type;
62 : : u8 possible_count;
63 : : u32 possible[ACPI_PCI_LINK_MAX_POSSIBLE];
64 : : u8 initialized:1;
65 : : u8 reserved:7;
66 : : };
67 : :
68 : : struct acpi_pci_link {
69 : : struct list_head list;
70 : : struct acpi_device *device;
71 : : struct acpi_pci_link_irq irq;
72 : : int refcnt;
73 : : };
74 : :
75 : : static LIST_HEAD(acpi_link_list);
76 : : static DEFINE_MUTEX(acpi_link_lock);
77 : : static int sci_irq = -1, sci_penalty;
78 : :
79 : : /* --------------------------------------------------------------------------
80 : : PCI Link Device Management
81 : : -------------------------------------------------------------------------- */
82 : :
83 : : /*
84 : : * set context (link) possible list from resource list
85 : : */
86 : 150 : static acpi_status acpi_pci_link_check_possible(struct acpi_resource *resource,
87 : : void *context)
88 : : {
89 : 150 : struct acpi_pci_link *link = context;
90 : 150 : u32 i;
91 : :
92 [ - + - - ]: 150 : switch (resource->type) {
93 : : case ACPI_RESOURCE_TYPE_START_DEPENDENT:
94 : : case ACPI_RESOURCE_TYPE_END_TAG:
95 : : return AE_OK;
96 : 0 : case ACPI_RESOURCE_TYPE_IRQ:
97 : : {
98 : 0 : struct acpi_resource_irq *p = &resource->data.irq;
99 [ # # # # ]: 0 : if (!p || !p->interrupt_count) {
100 : : ACPI_DEBUG_PRINT((ACPI_DB_INFO,
101 : : "Blank _PRS IRQ resource\n"));
102 : : return AE_OK;
103 : : }
104 : 0 : for (i = 0;
105 [ # # ]: 0 : (i < p->interrupt_count
106 [ # # ]: 0 : && i < ACPI_PCI_LINK_MAX_POSSIBLE); i++) {
107 [ # # ]: 0 : if (!p->interrupts[i]) {
108 : 0 : printk(KERN_WARNING PREFIX
109 : : "Invalid _PRS IRQ %d\n",
110 : : p->interrupts[i]);
111 : 0 : continue;
112 : : }
113 : 0 : link->irq.possible[i] = p->interrupts[i];
114 : 0 : link->irq.possible_count++;
115 : : }
116 : 0 : link->irq.triggering = p->triggering;
117 : 0 : link->irq.polarity = p->polarity;
118 : 0 : link->irq.resource_type = ACPI_RESOURCE_TYPE_IRQ;
119 : 0 : break;
120 : : }
121 : 150 : case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
122 : : {
123 : 150 : struct acpi_resource_extended_irq *p =
124 : : &resource->data.extended_irq;
125 [ + - - + ]: 150 : if (!p || !p->interrupt_count) {
126 : 0 : printk(KERN_WARNING PREFIX
127 : : "Blank _PRS EXT IRQ resource\n");
128 : 0 : return AE_OK;
129 : : }
130 : 540 : for (i = 0;
131 [ + + ]: 540 : (i < p->interrupt_count
132 [ + - ]: 780 : && i < ACPI_PCI_LINK_MAX_POSSIBLE); i++) {
133 [ - + ]: 390 : if (!p->interrupts[i]) {
134 : 0 : printk(KERN_WARNING PREFIX
135 : : "Invalid _PRS IRQ %d\n",
136 : : p->interrupts[i]);
137 : 0 : continue;
138 : : }
139 : 390 : link->irq.possible[i] = p->interrupts[i];
140 : 390 : link->irq.possible_count++;
141 : : }
142 : 150 : link->irq.triggering = p->triggering;
143 : 150 : link->irq.polarity = p->polarity;
144 : 150 : link->irq.resource_type = ACPI_RESOURCE_TYPE_EXTENDED_IRQ;
145 : 150 : break;
146 : : }
147 : 0 : default:
148 : 0 : printk(KERN_ERR PREFIX "_PRS resource type 0x%x isn't an IRQ\n",
149 : : resource->type);
150 : 0 : return AE_OK;
151 : : }
152 : :
153 : : return AE_CTRL_TERMINATE;
154 : : }
155 : :
156 : 150 : static int acpi_pci_link_get_possible(struct acpi_pci_link *link)
157 : : {
158 : 150 : acpi_status status;
159 : :
160 : 150 : status = acpi_walk_resources(link->device->handle, METHOD_NAME__PRS,
161 : : acpi_pci_link_check_possible, link);
162 : 150 : if (ACPI_FAILURE(status)) {
163 : : acpi_handle_debug(link->device->handle, "_PRS not present or invalid");
164 : : return 0;
165 : : }
166 : :
167 : : ACPI_DEBUG_PRINT((ACPI_DB_INFO,
168 : : "Found %d possible IRQs\n",
169 : : link->irq.possible_count));
170 : :
171 : : return 0;
172 : : }
173 : :
174 : 180 : static acpi_status acpi_pci_link_check_current(struct acpi_resource *resource,
175 : : void *context)
176 : : {
177 : 180 : int *irq = context;
178 : :
179 [ - + - - ]: 180 : switch (resource->type) {
180 : : case ACPI_RESOURCE_TYPE_START_DEPENDENT:
181 : : case ACPI_RESOURCE_TYPE_END_TAG:
182 : : return AE_OK;
183 : 0 : case ACPI_RESOURCE_TYPE_IRQ:
184 : : {
185 : 0 : struct acpi_resource_irq *p = &resource->data.irq;
186 [ # # # # ]: 0 : if (!p || !p->interrupt_count) {
187 : : /*
188 : : * IRQ descriptors may have no IRQ# bits set,
189 : : * particularly those those w/ _STA disabled
190 : : */
191 : : ACPI_DEBUG_PRINT((ACPI_DB_INFO,
192 : : "Blank _CRS IRQ resource\n"));
193 : : return AE_OK;
194 : : }
195 : 0 : *irq = p->interrupts[0];
196 : 0 : break;
197 : : }
198 : 180 : case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
199 : : {
200 : 180 : struct acpi_resource_extended_irq *p =
201 : : &resource->data.extended_irq;
202 [ + - - + ]: 180 : if (!p || !p->interrupt_count) {
203 : : /*
204 : : * extended IRQ descriptors must
205 : : * return at least 1 IRQ
206 : : */
207 : 0 : printk(KERN_WARNING PREFIX
208 : : "Blank _CRS EXT IRQ resource\n");
209 : 0 : return AE_OK;
210 : : }
211 : 180 : *irq = p->interrupts[0];
212 : 180 : break;
213 : : }
214 : 0 : break;
215 : 0 : default:
216 : 0 : printk(KERN_ERR PREFIX "_CRS resource type 0x%x isn't an IRQ\n",
217 : : resource->type);
218 : 0 : return AE_OK;
219 : : }
220 : :
221 : : return AE_CTRL_TERMINATE;
222 : : }
223 : :
224 : : /*
225 : : * Run _CRS and set link->irq.active
226 : : *
227 : : * return value:
228 : : * 0 - success
229 : : * !0 - failure
230 : : */
231 : : static int acpi_pci_link_get_current(struct acpi_pci_link *link)
232 : : {
233 : : int result = 0;
234 : : acpi_status status;
235 : : int irq = 0;
236 : :
237 : : link->irq.active = 0;
238 : :
239 : : /* in practice, status disabled is meaningless, ignore it */
240 : : if (acpi_strict) {
241 : : /* Query _STA, set link->device->status */
242 : : result = acpi_bus_get_status(link->device);
243 : : if (result) {
244 : : printk(KERN_ERR PREFIX "Unable to read status\n");
245 : : goto end;
246 : : }
247 : :
248 : : if (!link->device->status.enabled) {
249 : : ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Link disabled\n"));
250 : : return 0;
251 : : }
252 : : }
253 : :
254 : : /*
255 : : * Query and parse _CRS to get the current IRQ assignment.
256 : : */
257 : :
258 : : status = acpi_walk_resources(link->device->handle, METHOD_NAME__CRS,
259 : : acpi_pci_link_check_current, &irq);
260 : : if (ACPI_FAILURE(status)) {
261 : : ACPI_EXCEPTION((AE_INFO, status, "Evaluating _CRS"));
262 : : result = -ENODEV;
263 : : goto end;
264 : : }
265 : :
266 : : if (acpi_strict && !irq) {
267 : : printk(KERN_ERR PREFIX "_CRS returned 0\n");
268 : : result = -ENODEV;
269 : : }
270 : :
271 : : link->irq.active = irq;
272 : :
273 : : ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Link at IRQ %d \n", link->irq.active));
274 : :
275 : : end:
276 : : return result;
277 : : }
278 : :
279 : 30 : static int acpi_pci_link_set(struct acpi_pci_link *link, int irq)
280 : : {
281 : 30 : int result;
282 : 30 : acpi_status status;
283 : 30 : struct {
284 : : struct acpi_resource res;
285 : : struct acpi_resource end;
286 : : } *resource;
287 : 30 : struct acpi_buffer buffer = { 0, NULL };
288 : :
289 [ + - ]: 30 : if (!irq)
290 : : return -EINVAL;
291 : :
292 [ + - ]: 60 : resource = kzalloc(sizeof(*resource) + 1, irqs_disabled() ? GFP_ATOMIC: GFP_KERNEL);
293 [ + - ]: 30 : if (!resource)
294 : : return -ENOMEM;
295 : :
296 : 30 : buffer.length = sizeof(*resource) + 1;
297 : 30 : buffer.pointer = resource;
298 : :
299 [ - + - ]: 30 : switch (link->irq.resource_type) {
300 : 0 : case ACPI_RESOURCE_TYPE_IRQ:
301 : 0 : resource->res.type = ACPI_RESOURCE_TYPE_IRQ;
302 : 0 : resource->res.length = sizeof(struct acpi_resource);
303 : 0 : resource->res.data.irq.triggering = link->irq.triggering;
304 : 0 : resource->res.data.irq.polarity =
305 : 0 : link->irq.polarity;
306 [ # # ]: 0 : if (link->irq.triggering == ACPI_EDGE_SENSITIVE)
307 : 0 : resource->res.data.irq.shareable =
308 : : ACPI_EXCLUSIVE;
309 : : else
310 : 0 : resource->res.data.irq.shareable = ACPI_SHARED;
311 : 0 : resource->res.data.irq.interrupt_count = 1;
312 : 0 : resource->res.data.irq.interrupts[0] = irq;
313 : 0 : break;
314 : :
315 : 30 : case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
316 : 30 : resource->res.type = ACPI_RESOURCE_TYPE_EXTENDED_IRQ;
317 : 30 : resource->res.length = sizeof(struct acpi_resource);
318 : 30 : resource->res.data.extended_irq.producer_consumer =
319 : : ACPI_CONSUMER;
320 : 30 : resource->res.data.extended_irq.triggering =
321 : 30 : link->irq.triggering;
322 : 30 : resource->res.data.extended_irq.polarity =
323 : 30 : link->irq.polarity;
324 [ - + ]: 30 : if (link->irq.triggering == ACPI_EDGE_SENSITIVE)
325 : 0 : resource->res.data.irq.shareable =
326 : : ACPI_EXCLUSIVE;
327 : : else
328 : 30 : resource->res.data.irq.shareable = ACPI_SHARED;
329 : 30 : resource->res.data.extended_irq.interrupt_count = 1;
330 : 30 : resource->res.data.extended_irq.interrupts[0] = irq;
331 : : /* ignore resource_source, it's optional */
332 : 30 : break;
333 : 0 : default:
334 : 0 : printk(KERN_ERR PREFIX "Invalid Resource_type %d\n", link->irq.resource_type);
335 : 0 : result = -EINVAL;
336 : 0 : goto end;
337 : :
338 : : }
339 : 30 : resource->end.type = ACPI_RESOURCE_TYPE_END_TAG;
340 : 30 : resource->end.length = sizeof(struct acpi_resource);
341 : :
342 : : /* Attempt to set the resource */
343 : 30 : status = acpi_set_current_resources(link->device->handle, &buffer);
344 : :
345 : : /* check for total failure */
346 [ - + ]: 30 : if (ACPI_FAILURE(status)) {
347 : 0 : ACPI_EXCEPTION((AE_INFO, status, "Evaluating _SRS"));
348 : 0 : result = -ENODEV;
349 : 0 : goto end;
350 : : }
351 : :
352 : : /* Query _STA, set device->status */
353 : 30 : result = acpi_bus_get_status(link->device);
354 [ - + ]: 30 : if (result) {
355 : 0 : printk(KERN_ERR PREFIX "Unable to read status\n");
356 : 0 : goto end;
357 : : }
358 [ - + ]: 30 : if (!link->device->status.enabled) {
359 : 0 : printk(KERN_WARNING PREFIX
360 : : "%s [%s] disabled and referenced, BIOS bug\n",
361 : 0 : acpi_device_name(link->device),
362 : 0 : acpi_device_bid(link->device));
363 : : }
364 : :
365 : : /* Query _CRS, set link->irq.active */
366 : 30 : result = acpi_pci_link_get_current(link);
367 [ - + ]: 30 : if (result) {
368 : 0 : goto end;
369 : : }
370 : :
371 : : /*
372 : : * Is current setting not what we set?
373 : : * set link->irq.active
374 : : */
375 [ + - ]: 30 : if (link->irq.active != irq) {
376 : : /*
377 : : * policy: when _CRS doesn't return what we just _SRS
378 : : * assume _SRS worked and override _CRS value.
379 : : */
380 : 0 : printk(KERN_WARNING PREFIX
381 : : "%s [%s] BIOS reported IRQ %d, using IRQ %d\n",
382 : 0 : acpi_device_name(link->device),
383 : 0 : acpi_device_bid(link->device), link->irq.active, irq);
384 : 0 : link->irq.active = irq;
385 : : }
386 : :
387 : 30 : ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Set IRQ %d\n", link->irq.active));
388 : :
389 : 30 : end:
390 : 30 : kfree(resource);
391 : 30 : return result;
392 : : }
393 : :
394 : : /* --------------------------------------------------------------------------
395 : : PCI Link IRQ Management
396 : : -------------------------------------------------------------------------- */
397 : :
398 : : /*
399 : : * "acpi_irq_balance" (default in APIC mode) enables ACPI to use PIC Interrupt
400 : : * Link Devices to move the PIRQs around to minimize sharing.
401 : : *
402 : : * "acpi_irq_nobalance" (default in PIC mode) tells ACPI not to move any PIC IRQs
403 : : * that the BIOS has already set to active. This is necessary because
404 : : * ACPI has no automatic means of knowing what ISA IRQs are used. Note that
405 : : * if the BIOS doesn't set a Link Device active, ACPI needs to program it
406 : : * even if acpi_irq_nobalance is set.
407 : : *
408 : : * A tables of penalties avoids directing PCI interrupts to well known
409 : : * ISA IRQs. Boot params are available to over-ride the default table:
410 : : *
411 : : * List interrupts that are free for PCI use.
412 : : * acpi_irq_pci=n[,m]
413 : : *
414 : : * List interrupts that should not be used for PCI:
415 : : * acpi_irq_isa=n[,m]
416 : : *
417 : : * Note that PCI IRQ routers have a list of possible IRQs,
418 : : * which may not include the IRQs this table says are available.
419 : : *
420 : : * Since this heuristic can't tell the difference between a link
421 : : * that no device will attach to, vs. a link which may be shared
422 : : * by multiple active devices -- it is not optimal.
423 : : *
424 : : * If interrupt performance is that important, get an IO-APIC system
425 : : * with a pin dedicated to each device. Or for that matter, an MSI
426 : : * enabled system.
427 : : */
428 : :
429 : : #define ACPI_MAX_ISA_IRQS 16
430 : :
431 : : #define PIRQ_PENALTY_PCI_POSSIBLE (16*16)
432 : : #define PIRQ_PENALTY_PCI_USING (16*16*16)
433 : : #define PIRQ_PENALTY_ISA_TYPICAL (16*16*16*16)
434 : : #define PIRQ_PENALTY_ISA_USED (16*16*16*16*16)
435 : : #define PIRQ_PENALTY_ISA_ALWAYS (16*16*16*16*16*16)
436 : :
437 : : static int acpi_isa_irq_penalty[ACPI_MAX_ISA_IRQS] = {
438 : : PIRQ_PENALTY_ISA_ALWAYS, /* IRQ0 timer */
439 : : PIRQ_PENALTY_ISA_ALWAYS, /* IRQ1 keyboard */
440 : : PIRQ_PENALTY_ISA_ALWAYS, /* IRQ2 cascade */
441 : : PIRQ_PENALTY_ISA_TYPICAL, /* IRQ3 serial */
442 : : PIRQ_PENALTY_ISA_TYPICAL, /* IRQ4 serial */
443 : : PIRQ_PENALTY_ISA_TYPICAL, /* IRQ5 sometimes SoundBlaster */
444 : : PIRQ_PENALTY_ISA_TYPICAL, /* IRQ6 */
445 : : PIRQ_PENALTY_ISA_TYPICAL, /* IRQ7 parallel, spurious */
446 : : PIRQ_PENALTY_ISA_TYPICAL, /* IRQ8 rtc, sometimes */
447 : : 0, /* IRQ9 PCI, often acpi */
448 : : 0, /* IRQ10 PCI */
449 : : 0, /* IRQ11 PCI */
450 : : PIRQ_PENALTY_ISA_USED, /* IRQ12 mouse */
451 : : PIRQ_PENALTY_ISA_USED, /* IRQ13 fpe, sometimes */
452 : : PIRQ_PENALTY_ISA_USED, /* IRQ14 ide0 */
453 : : PIRQ_PENALTY_ISA_USED, /* IRQ15 ide1 */
454 : : /* >IRQ15 */
455 : : };
456 : :
457 : 0 : static int acpi_irq_pci_sharing_penalty(int irq)
458 : : {
459 : 0 : struct acpi_pci_link *link;
460 : 0 : int penalty = 0;
461 : 0 : int i;
462 : :
463 [ # # ]: 0 : list_for_each_entry(link, &acpi_link_list, list) {
464 : : /*
465 : : * If a link is active, penalize its IRQ heavily
466 : : * so we try to choose a different IRQ.
467 : : */
468 [ # # # # ]: 0 : if (link->irq.active && link->irq.active == irq)
469 : 0 : penalty += PIRQ_PENALTY_PCI_USING;
470 : :
471 : : /*
472 : : * penalize the IRQs PCI might use, but not as severely.
473 : : */
474 [ # # ]: 0 : for (i = 0; i < link->irq.possible_count; i++)
475 [ # # ]: 0 : if (link->irq.possible[i] == irq)
476 : 0 : penalty += PIRQ_PENALTY_PCI_POSSIBLE /
477 : : link->irq.possible_count;
478 : : }
479 : :
480 : 0 : return penalty;
481 : : }
482 : :
483 : 210 : static int acpi_irq_get_penalty(int irq)
484 : : {
485 : 210 : int penalty = 0;
486 : :
487 [ - + ]: 210 : if (irq == sci_irq)
488 : 0 : penalty += sci_penalty;
489 : :
490 [ + - ]: 210 : if (irq < ACPI_MAX_ISA_IRQS)
491 : 210 : return penalty + acpi_isa_irq_penalty[irq];
492 : :
493 : 0 : return penalty + acpi_irq_pci_sharing_penalty(irq);
494 : : }
495 : :
496 : 30 : int __init acpi_irq_penalty_init(void)
497 : : {
498 : 30 : struct acpi_pci_link *link;
499 : 30 : int i;
500 : :
501 : : /*
502 : : * Update penalties to facilitate IRQ balancing.
503 : : */
504 [ + + ]: 180 : list_for_each_entry(link, &acpi_link_list, list) {
505 : :
506 : : /*
507 : : * reflect the possible and active irqs in the penalty table --
508 : : * useful for breaking ties.
509 : : */
510 [ + - ]: 150 : if (link->irq.possible_count) {
511 : 150 : int penalty =
512 : : PIRQ_PENALTY_PCI_POSSIBLE /
513 : 150 : link->irq.possible_count;
514 : :
515 [ + + ]: 540 : for (i = 0; i < link->irq.possible_count; i++) {
516 [ + - ]: 390 : if (link->irq.possible[i] < ACPI_MAX_ISA_IRQS)
517 : 390 : acpi_isa_irq_penalty[link->irq.
518 : 390 : possible[i]] +=
519 : : penalty;
520 : : }
521 : :
522 [ # # ]: 0 : } else if (link->irq.active &&
523 : : (link->irq.active < ACPI_MAX_ISA_IRQS)) {
524 : 0 : acpi_isa_irq_penalty[link->irq.active] +=
525 : : PIRQ_PENALTY_PCI_POSSIBLE;
526 : : }
527 : : }
528 : :
529 : 30 : return 0;
530 : : }
531 : :
532 : : static int acpi_irq_balance = -1; /* 0: static, 1: balance */
533 : :
534 : 30 : static int acpi_pci_link_allocate(struct acpi_pci_link *link)
535 : : {
536 : 30 : int irq;
537 : 30 : int i;
538 : :
539 [ - + ]: 30 : if (link->irq.initialized) {
540 [ # # ]: 0 : if (link->refcnt == 0)
541 : : /* This means the link is disabled but initialized */
542 : 0 : acpi_pci_link_set(link, link->irq.active);
543 : 0 : return 0;
544 : : }
545 : :
546 : : /*
547 : : * search for active IRQ in list of possible IRQs.
548 : : */
549 [ + - ]: 90 : for (i = 0; i < link->irq.possible_count; ++i) {
550 [ + + ]: 90 : if (link->irq.active == link->irq.possible[i])
551 : : break;
552 : : }
553 : : /*
554 : : * forget active IRQ that is not in possible list
555 : : */
556 [ - + ]: 30 : if (i == link->irq.possible_count) {
557 [ # # ]: 0 : if (acpi_strict)
558 : 0 : printk(KERN_WARNING PREFIX "_CRS %d not found"
559 : : " in _PRS\n", link->irq.active);
560 : 0 : link->irq.active = 0;
561 : : }
562 : :
563 : : /*
564 : : * if active found, use it; else pick entry from end of possible list.
565 : : */
566 [ + - ]: 30 : if (link->irq.active)
567 : 30 : irq = link->irq.active;
568 : : else
569 : 0 : irq = link->irq.possible[link->irq.possible_count - 1];
570 : :
571 [ - + - - ]: 30 : if (acpi_irq_balance || !link->irq.active) {
572 : : /*
573 : : * Select the best IRQ. This is done in reverse to promote
574 : : * the use of IRQs 9, 10, 11, and >15.
575 : : */
576 [ + + ]: 120 : for (i = (link->irq.possible_count - 1); i >= 0; i--) {
577 [ - + ]: 180 : if (acpi_irq_get_penalty(irq) >
578 : 90 : acpi_irq_get_penalty(link->irq.possible[i]))
579 : 0 : irq = link->irq.possible[i];
580 : : }
581 : : }
582 [ - + ]: 30 : if (acpi_irq_get_penalty(irq) >= PIRQ_PENALTY_ISA_ALWAYS) {
583 : 0 : printk(KERN_ERR PREFIX "No IRQ available for %s [%s]. "
584 : : "Try pci=noacpi or acpi=off\n",
585 : 0 : acpi_device_name(link->device),
586 : 0 : acpi_device_bid(link->device));
587 : 0 : return -ENODEV;
588 : : }
589 : :
590 : : /* Attempt to enable the link device at this IRQ. */
591 [ - + ]: 30 : if (acpi_pci_link_set(link, irq)) {
592 : 0 : printk(KERN_ERR PREFIX "Unable to set IRQ for %s [%s]. "
593 : : "Try pci=noacpi or acpi=off\n",
594 : 0 : acpi_device_name(link->device),
595 : 0 : acpi_device_bid(link->device));
596 : 0 : return -ENODEV;
597 : : } else {
598 [ + - ]: 30 : if (link->irq.active < ACPI_MAX_ISA_IRQS)
599 : 30 : acpi_isa_irq_penalty[link->irq.active] +=
600 : : PIRQ_PENALTY_PCI_USING;
601 : :
602 : 30 : pr_info("%s [%s] enabled at IRQ %d\n",
603 : : acpi_device_name(link->device),
604 : : acpi_device_bid(link->device), link->irq.active);
605 : : }
606 : :
607 : 30 : link->irq.initialized = 1;
608 : 30 : return 0;
609 : : }
610 : :
611 : : /*
612 : : * acpi_pci_link_allocate_irq
613 : : * success: return IRQ >= 0
614 : : * failure: return -1
615 : : */
616 : 30 : int acpi_pci_link_allocate_irq(acpi_handle handle, int index, int *triggering,
617 : : int *polarity, char **name)
618 : : {
619 : 30 : int result;
620 : 30 : struct acpi_device *device;
621 : 30 : struct acpi_pci_link *link;
622 : :
623 : 30 : result = acpi_bus_get_device(handle, &device);
624 [ - + ]: 30 : if (result) {
625 : 0 : printk(KERN_ERR PREFIX "Invalid link device\n");
626 : 0 : return -1;
627 : : }
628 : :
629 [ - + ]: 30 : link = acpi_driver_data(device);
630 [ - + ]: 30 : if (!link) {
631 : 0 : printk(KERN_ERR PREFIX "Invalid link context\n");
632 : 0 : return -1;
633 : : }
634 : :
635 : : /* TBD: Support multiple index (IRQ) entries per Link Device */
636 [ - + ]: 30 : if (index) {
637 : 0 : printk(KERN_ERR PREFIX "Invalid index %d\n", index);
638 : 0 : return -1;
639 : : }
640 : :
641 : 30 : mutex_lock(&acpi_link_lock);
642 [ - + ]: 30 : if (acpi_pci_link_allocate(link)) {
643 : 0 : mutex_unlock(&acpi_link_lock);
644 : 0 : return -1;
645 : : }
646 : :
647 [ - + ]: 30 : if (!link->irq.active) {
648 : 0 : mutex_unlock(&acpi_link_lock);
649 : 0 : printk(KERN_ERR PREFIX "Link active IRQ is 0!\n");
650 : 0 : return -1;
651 : : }
652 : 30 : link->refcnt++;
653 : 30 : mutex_unlock(&acpi_link_lock);
654 : :
655 [ + - ]: 30 : if (triggering)
656 : 30 : *triggering = link->irq.triggering;
657 [ + - ]: 30 : if (polarity)
658 : 30 : *polarity = link->irq.polarity;
659 [ + - ]: 30 : if (name)
660 : 30 : *name = acpi_device_bid(link->device);
661 : : ACPI_DEBUG_PRINT((ACPI_DB_INFO,
662 : : "Link %s is referenced\n",
663 : 30 : acpi_device_bid(link->device)));
664 : 30 : return link->irq.active;
665 : : }
666 : :
667 : : /*
668 : : * We don't change link's irq information here. After it is reenabled, we
669 : : * continue use the info
670 : : */
671 : 24 : int acpi_pci_link_free_irq(acpi_handle handle)
672 : : {
673 : 24 : struct acpi_device *device;
674 : 24 : struct acpi_pci_link *link;
675 : 24 : acpi_status result;
676 : :
677 : 24 : result = acpi_bus_get_device(handle, &device);
678 [ - + ]: 24 : if (result) {
679 : 0 : printk(KERN_ERR PREFIX "Invalid link device\n");
680 : 0 : return -1;
681 : : }
682 : :
683 [ - + ]: 24 : link = acpi_driver_data(device);
684 [ - + ]: 24 : if (!link) {
685 : 0 : printk(KERN_ERR PREFIX "Invalid link context\n");
686 : 0 : return -1;
687 : : }
688 : :
689 : 24 : mutex_lock(&acpi_link_lock);
690 [ - + ]: 24 : if (!link->irq.initialized) {
691 : 0 : mutex_unlock(&acpi_link_lock);
692 : 0 : printk(KERN_ERR PREFIX "Link isn't initialized\n");
693 : 0 : return -1;
694 : : }
695 : : #ifdef FUTURE_USE
696 : : /*
697 : : * The Link reference count allows us to _DISable an unused link
698 : : * and suspend time, and set it again on resume.
699 : : * However, 2.6.12 still has irq_router.resume
700 : : * which blindly restores the link state.
701 : : * So we disable the reference count method
702 : : * to prevent duplicate acpi_pci_link_set()
703 : : * which would harm some systems
704 : : */
705 : : link->refcnt--;
706 : : #endif
707 : : ACPI_DEBUG_PRINT((ACPI_DB_INFO,
708 : : "Link %s is dereferenced\n",
709 : 24 : acpi_device_bid(link->device)));
710 : :
711 [ - + ]: 24 : if (link->refcnt == 0)
712 : 0 : acpi_evaluate_object(link->device->handle, "_DIS", NULL, NULL);
713 : :
714 : 24 : mutex_unlock(&acpi_link_lock);
715 : 24 : return link->irq.active;
716 : : }
717 : :
718 : : /* --------------------------------------------------------------------------
719 : : Driver Interface
720 : : -------------------------------------------------------------------------- */
721 : :
722 : 150 : static int acpi_pci_link_add(struct acpi_device *device,
723 : : const struct acpi_device_id *not_used)
724 : : {
725 : 150 : int result;
726 : 150 : struct acpi_pci_link *link;
727 : 150 : int i;
728 : 150 : int found = 0;
729 : :
730 : 150 : link = kzalloc(sizeof(struct acpi_pci_link), GFP_KERNEL);
731 [ + - ]: 150 : if (!link)
732 : : return -ENOMEM;
733 : :
734 : 150 : link->device = device;
735 : 150 : strcpy(acpi_device_name(device), ACPI_PCI_LINK_DEVICE_NAME);
736 : 150 : strcpy(acpi_device_class(device), ACPI_PCI_LINK_CLASS);
737 : 150 : device->driver_data = link;
738 : :
739 : 150 : mutex_lock(&acpi_link_lock);
740 : 150 : result = acpi_pci_link_get_possible(link);
741 : 150 : if (result)
742 : : goto end;
743 : :
744 : : /* query and set link->irq.active */
745 : 150 : acpi_pci_link_get_current(link);
746 : :
747 : 150 : printk(KERN_INFO PREFIX "%s [%s] (IRQs", acpi_device_name(device),
748 : 150 : acpi_device_bid(device));
749 [ + + ]: 690 : for (i = 0; i < link->irq.possible_count; i++) {
750 [ + + ]: 390 : if (link->irq.active == link->irq.possible[i]) {
751 : 150 : printk(KERN_CONT " *%d", link->irq.possible[i]);
752 : 150 : found = 1;
753 : : } else
754 : 240 : printk(KERN_CONT " %d", link->irq.possible[i]);
755 : : }
756 : :
757 : 150 : printk(KERN_CONT ")");
758 : :
759 [ - + ]: 150 : if (!found)
760 : 0 : printk(KERN_CONT " *%d", link->irq.active);
761 : :
762 [ - + ]: 150 : if (!link->device->status.enabled)
763 : 0 : printk(KERN_CONT ", disabled.");
764 : :
765 : 150 : printk(KERN_CONT "\n");
766 : :
767 : 150 : list_add_tail(&link->list, &acpi_link_list);
768 : :
769 : : end:
770 : : /* disable all links -- to be activated on use */
771 : 150 : acpi_evaluate_object(device->handle, "_DIS", NULL, NULL);
772 : 150 : mutex_unlock(&acpi_link_lock);
773 : :
774 : 150 : if (result)
775 : : kfree(link);
776 : :
777 : 150 : return result < 0 ? result : 1;
778 : : }
779 : :
780 : 0 : static int acpi_pci_link_resume(struct acpi_pci_link *link)
781 : : {
782 [ # # # # : 0 : if (link->refcnt && link->irq.active && link->irq.initialized)
# # ]
783 : 0 : return (acpi_pci_link_set(link, link->irq.active));
784 : :
785 : : return 0;
786 : : }
787 : :
788 : 0 : static void irqrouter_resume(void)
789 : : {
790 : 0 : struct acpi_pci_link *link;
791 : :
792 [ # # ]: 0 : list_for_each_entry(link, &acpi_link_list, list) {
793 : 0 : acpi_pci_link_resume(link);
794 : : }
795 : 0 : }
796 : :
797 : 0 : static void acpi_pci_link_remove(struct acpi_device *device)
798 : : {
799 : 0 : struct acpi_pci_link *link;
800 : :
801 : 0 : link = acpi_driver_data(device);
802 : :
803 : 0 : mutex_lock(&acpi_link_lock);
804 : 0 : list_del(&link->list);
805 : 0 : mutex_unlock(&acpi_link_lock);
806 : :
807 : 0 : kfree(link);
808 : 0 : }
809 : :
810 : : /*
811 : : * modify acpi_isa_irq_penalty[] from cmdline
812 : : */
813 : 0 : static int __init acpi_irq_penalty_update(char *str, int used)
814 : : {
815 : 0 : int i;
816 : :
817 [ # # ]: 0 : for (i = 0; i < 16; i++) {
818 : 0 : int retval;
819 : 0 : int irq;
820 : 0 : int new_penalty;
821 : :
822 : 0 : retval = get_option(&str, &irq);
823 : :
824 [ # # ]: 0 : if (!retval)
825 : : break; /* no number found */
826 : :
827 : : /* see if this is a ISA IRQ */
828 [ # # ]: 0 : if ((irq < 0) || (irq >= ACPI_MAX_ISA_IRQS))
829 : 0 : continue;
830 : :
831 [ # # ]: 0 : if (used)
832 : 0 : new_penalty = acpi_isa_irq_penalty[irq] +
833 : : PIRQ_PENALTY_ISA_USED;
834 : : else
835 : : new_penalty = 0;
836 : :
837 : 0 : acpi_isa_irq_penalty[irq] = new_penalty;
838 [ # # ]: 0 : if (retval != 2) /* no next number */
839 : : break;
840 : : }
841 : 0 : return 1;
842 : : }
843 : :
844 : : /*
845 : : * We'd like PNP to call this routine for the
846 : : * single ISA_USED value for each legacy device.
847 : : * But instead it calls us with each POSSIBLE setting.
848 : : * There is no ISA_POSSIBLE weight, so we simply use
849 : : * the (small) PCI_USING penalty.
850 : : */
851 : 180 : void acpi_penalize_isa_irq(int irq, int active)
852 : : {
853 [ + - ]: 180 : if ((irq >= 0) && (irq < ARRAY_SIZE(acpi_isa_irq_penalty)))
854 : 180 : acpi_isa_irq_penalty[irq] +=
855 [ - + ]: 180 : (active ? PIRQ_PENALTY_ISA_USED : PIRQ_PENALTY_PCI_USING);
856 : 180 : }
857 : :
858 : 0 : bool acpi_isa_irq_available(int irq)
859 : : {
860 [ # # # # : 0 : return irq >= 0 && (irq >= ARRAY_SIZE(acpi_isa_irq_penalty) ||
# # ]
861 : 0 : acpi_irq_get_penalty(irq) < PIRQ_PENALTY_ISA_ALWAYS);
862 : : }
863 : :
864 : 30 : void acpi_penalize_sci_irq(int irq, int trigger, int polarity)
865 : : {
866 : 30 : sci_irq = irq;
867 : :
868 : 30 : if (trigger == ACPI_MADT_TRIGGER_LEVEL &&
869 [ - + ]: 30 : polarity == ACPI_MADT_POLARITY_ACTIVE_LOW)
870 : 0 : sci_penalty = PIRQ_PENALTY_PCI_USING;
871 : : else
872 : 30 : sci_penalty = PIRQ_PENALTY_ISA_ALWAYS;
873 : 30 : }
874 : :
875 : : /*
876 : : * Over-ride default table to reserve additional IRQs for use by ISA
877 : : * e.g. acpi_irq_isa=5
878 : : * Useful for telling ACPI how not to interfere with your ISA sound card.
879 : : */
880 : 0 : static int __init acpi_irq_isa(char *str)
881 : : {
882 : 0 : return acpi_irq_penalty_update(str, 1);
883 : : }
884 : :
885 : : __setup("acpi_irq_isa=", acpi_irq_isa);
886 : :
887 : : /*
888 : : * Over-ride default table to free additional IRQs for use by PCI
889 : : * e.g. acpi_irq_pci=7,15
890 : : * Used for acpi_irq_balance to free up IRQs to reduce PCI IRQ sharing.
891 : : */
892 : 0 : static int __init acpi_irq_pci(char *str)
893 : : {
894 : 0 : return acpi_irq_penalty_update(str, 0);
895 : : }
896 : :
897 : : __setup("acpi_irq_pci=", acpi_irq_pci);
898 : :
899 : 0 : static int __init acpi_irq_nobalance_set(char *str)
900 : : {
901 : 0 : acpi_irq_balance = 0;
902 : 0 : return 1;
903 : : }
904 : :
905 : : __setup("acpi_irq_nobalance", acpi_irq_nobalance_set);
906 : :
907 : 0 : static int __init acpi_irq_balance_set(char *str)
908 : : {
909 : 0 : acpi_irq_balance = 1;
910 : 0 : return 1;
911 : : }
912 : :
913 : : __setup("acpi_irq_balance", acpi_irq_balance_set);
914 : :
915 : : static struct syscore_ops irqrouter_syscore_ops = {
916 : : .resume = irqrouter_resume,
917 : : };
918 : :
919 : 30 : void __init acpi_pci_link_init(void)
920 : : {
921 [ + - ]: 30 : if (acpi_noirq)
922 : : return;
923 : :
924 [ + - ]: 30 : if (acpi_irq_balance == -1) {
925 : : /* no command line switch: enable balancing in IOAPIC mode */
926 [ + - ]: 30 : if (acpi_irq_model == ACPI_IRQ_MODEL_IOAPIC)
927 : 30 : acpi_irq_balance = 1;
928 : : else
929 : 0 : acpi_irq_balance = 0;
930 : : }
931 : 30 : register_syscore_ops(&irqrouter_syscore_ops);
932 : 30 : acpi_scan_add_handler(&pci_link_handler);
933 : : }
|
