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