Version:  2.0.40 2.2.26 2.4.37 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7

Linux/drivers/acpi/pci_link.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us