pci_link.c 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899
  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. #include <linux/sysdev.h>
  32. #include <linux/kernel.h>
  33. #include <linux/module.h>
  34. #include <linux/init.h>
  35. #include <linux/types.h>
  36. #include <linux/proc_fs.h>
  37. #include <linux/spinlock.h>
  38. #include <linux/pm.h>
  39. #include <linux/pci.h>
  40. #include <acpi/acpi_bus.h>
  41. #include <acpi/acpi_drivers.h>
  42. #define _COMPONENT ACPI_PCI_COMPONENT
  43. ACPI_MODULE_NAME ("pci_link")
  44. #define ACPI_PCI_LINK_CLASS "pci_irq_routing"
  45. #define ACPI_PCI_LINK_HID "PNP0C0F"
  46. #define ACPI_PCI_LINK_DRIVER_NAME "ACPI PCI Interrupt Link Driver"
  47. #define ACPI_PCI_LINK_DEVICE_NAME "PCI Interrupt Link"
  48. #define ACPI_PCI_LINK_FILE_INFO "info"
  49. #define ACPI_PCI_LINK_FILE_STATUS "state"
  50. #define ACPI_PCI_LINK_MAX_POSSIBLE 16
  51. static int acpi_pci_link_add (struct acpi_device *device);
  52. static int acpi_pci_link_remove (struct acpi_device *device, int type);
  53. static struct acpi_driver acpi_pci_link_driver = {
  54. .name = ACPI_PCI_LINK_DRIVER_NAME,
  55. .class = ACPI_PCI_LINK_CLASS,
  56. .ids = ACPI_PCI_LINK_HID,
  57. .ops = {
  58. .add = acpi_pci_link_add,
  59. .remove = acpi_pci_link_remove,
  60. },
  61. };
  62. struct acpi_pci_link_irq {
  63. u8 active; /* Current IRQ */
  64. u8 edge_level; /* All IRQs */
  65. u8 active_high_low; /* All IRQs */
  66. u8 resource_type;
  67. u8 possible_count;
  68. u8 possible[ACPI_PCI_LINK_MAX_POSSIBLE];
  69. u8 initialized:1;
  70. u8 suspend_resume:1;
  71. u8 reserved:6;
  72. };
  73. struct acpi_pci_link {
  74. struct list_head node;
  75. struct acpi_device *device;
  76. acpi_handle handle;
  77. struct acpi_pci_link_irq irq;
  78. };
  79. static struct {
  80. int count;
  81. struct list_head entries;
  82. } acpi_link;
  83. /* --------------------------------------------------------------------------
  84. PCI Link Device Management
  85. -------------------------------------------------------------------------- */
  86. /*
  87. * set context (link) possible list from resource list
  88. */
  89. static acpi_status
  90. acpi_pci_link_check_possible (
  91. struct acpi_resource *resource,
  92. void *context)
  93. {
  94. struct acpi_pci_link *link = (struct acpi_pci_link *) context;
  95. u32 i = 0;
  96. ACPI_FUNCTION_TRACE("acpi_pci_link_check_possible");
  97. switch (resource->id) {
  98. case ACPI_RSTYPE_START_DPF:
  99. return_ACPI_STATUS(AE_OK);
  100. case ACPI_RSTYPE_IRQ:
  101. {
  102. struct acpi_resource_irq *p = &resource->data.irq;
  103. if (!p || !p->number_of_interrupts) {
  104. ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Blank IRQ resource\n"));
  105. return_ACPI_STATUS(AE_OK);
  106. }
  107. for (i = 0; (i<p->number_of_interrupts && i<ACPI_PCI_LINK_MAX_POSSIBLE); i++) {
  108. if (!p->interrupts[i]) {
  109. ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Invalid IRQ %d\n", p->interrupts[i]));
  110. continue;
  111. }
  112. link->irq.possible[i] = p->interrupts[i];
  113. link->irq.possible_count++;
  114. }
  115. link->irq.edge_level = p->edge_level;
  116. link->irq.active_high_low = p->active_high_low;
  117. link->irq.resource_type = ACPI_RSTYPE_IRQ;
  118. break;
  119. }
  120. case ACPI_RSTYPE_EXT_IRQ:
  121. {
  122. struct acpi_resource_ext_irq *p = &resource->data.extended_irq;
  123. if (!p || !p->number_of_interrupts) {
  124. ACPI_DEBUG_PRINT((ACPI_DB_WARN,
  125. "Blank EXT IRQ resource\n"));
  126. return_ACPI_STATUS(AE_OK);
  127. }
  128. for (i = 0; (i<p->number_of_interrupts && i<ACPI_PCI_LINK_MAX_POSSIBLE); i++) {
  129. if (!p->interrupts[i]) {
  130. ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Invalid IRQ %d\n", p->interrupts[i]));
  131. continue;
  132. }
  133. link->irq.possible[i] = p->interrupts[i];
  134. link->irq.possible_count++;
  135. }
  136. link->irq.edge_level = p->edge_level;
  137. link->irq.active_high_low = p->active_high_low;
  138. link->irq.resource_type = ACPI_RSTYPE_EXT_IRQ;
  139. break;
  140. }
  141. default:
  142. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  143. "Resource is not an IRQ entry\n"));
  144. return_ACPI_STATUS(AE_OK);
  145. }
  146. return_ACPI_STATUS(AE_CTRL_TERMINATE);
  147. }
  148. static int
  149. acpi_pci_link_get_possible (
  150. struct acpi_pci_link *link)
  151. {
  152. acpi_status status;
  153. ACPI_FUNCTION_TRACE("acpi_pci_link_get_possible");
  154. if (!link)
  155. return_VALUE(-EINVAL);
  156. status = acpi_walk_resources(link->handle, METHOD_NAME__PRS,
  157. acpi_pci_link_check_possible, link);
  158. if (ACPI_FAILURE(status)) {
  159. ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _PRS\n"));
  160. return_VALUE(-ENODEV);
  161. }
  162. ACPI_DEBUG_PRINT((ACPI_DB_INFO,
  163. "Found %d possible IRQs\n", link->irq.possible_count));
  164. return_VALUE(0);
  165. }
  166. static acpi_status
  167. acpi_pci_link_check_current (
  168. struct acpi_resource *resource,
  169. void *context)
  170. {
  171. int *irq = (int *) context;
  172. ACPI_FUNCTION_TRACE("acpi_pci_link_check_current");
  173. switch (resource->id) {
  174. case ACPI_RSTYPE_IRQ:
  175. {
  176. struct acpi_resource_irq *p = &resource->data.irq;
  177. if (!p || !p->number_of_interrupts) {
  178. /*
  179. * IRQ descriptors may have no IRQ# bits set,
  180. * particularly those those w/ _STA disabled
  181. */
  182. ACPI_DEBUG_PRINT((ACPI_DB_INFO,
  183. "Blank IRQ resource\n"));
  184. return_ACPI_STATUS(AE_OK);
  185. }
  186. *irq = p->interrupts[0];
  187. break;
  188. }
  189. case ACPI_RSTYPE_EXT_IRQ:
  190. {
  191. struct acpi_resource_ext_irq *p = &resource->data.extended_irq;
  192. if (!p || !p->number_of_interrupts) {
  193. /*
  194. * extended IRQ descriptors must
  195. * return at least 1 IRQ
  196. */
  197. ACPI_DEBUG_PRINT((ACPI_DB_WARN,
  198. "Blank EXT IRQ resource\n"));
  199. return_ACPI_STATUS(AE_OK);
  200. }
  201. *irq = p->interrupts[0];
  202. break;
  203. }
  204. default:
  205. ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
  206. "Resource isn't an IRQ\n"));
  207. return_ACPI_STATUS(AE_OK);
  208. }
  209. return_ACPI_STATUS(AE_CTRL_TERMINATE);
  210. }
  211. /*
  212. * Run _CRS and set link->irq.active
  213. *
  214. * return value:
  215. * 0 - success
  216. * !0 - failure
  217. */
  218. static int
  219. acpi_pci_link_get_current (
  220. struct acpi_pci_link *link)
  221. {
  222. int result = 0;
  223. acpi_status status = AE_OK;
  224. int irq = 0;
  225. ACPI_FUNCTION_TRACE("acpi_pci_link_get_current");
  226. if (!link || !link->handle)
  227. return_VALUE(-EINVAL);
  228. link->irq.active = 0;
  229. /* in practice, status disabled is meaningless, ignore it */
  230. if (acpi_strict) {
  231. /* Query _STA, set link->device->status */
  232. result = acpi_bus_get_status(link->device);
  233. if (result) {
  234. ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Unable to read status\n"));
  235. goto end;
  236. }
  237. if (!link->device->status.enabled) {
  238. ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Link disabled\n"));
  239. return_VALUE(0);
  240. }
  241. }
  242. /*
  243. * Query and parse _CRS to get the current IRQ assignment.
  244. */
  245. status = acpi_walk_resources(link->handle, METHOD_NAME__CRS,
  246. acpi_pci_link_check_current, &irq);
  247. if (ACPI_FAILURE(status)) {
  248. ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _CRS\n"));
  249. result = -ENODEV;
  250. goto end;
  251. }
  252. if (acpi_strict && !irq) {
  253. ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "_CRS returned 0\n"));
  254. result = -ENODEV;
  255. }
  256. link->irq.active = irq;
  257. ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Link at IRQ %d \n", link->irq.active));
  258. end:
  259. return_VALUE(result);
  260. }
  261. static int
  262. acpi_pci_link_set (
  263. struct acpi_pci_link *link,
  264. int irq)
  265. {
  266. int result = 0;
  267. acpi_status status = AE_OK;
  268. struct {
  269. struct acpi_resource res;
  270. struct acpi_resource end;
  271. } *resource;
  272. struct acpi_buffer buffer = {0, NULL};
  273. ACPI_FUNCTION_TRACE("acpi_pci_link_set");
  274. if (!link || !irq)
  275. return_VALUE(-EINVAL);
  276. resource = kmalloc( sizeof(*resource)+1, GFP_KERNEL);
  277. if(!resource)
  278. return_VALUE(-ENOMEM);
  279. memset(resource, 0, sizeof(*resource)+1);
  280. buffer.length = sizeof(*resource) +1;
  281. buffer.pointer = resource;
  282. switch(link->irq.resource_type) {
  283. case ACPI_RSTYPE_IRQ:
  284. resource->res.id = ACPI_RSTYPE_IRQ;
  285. resource->res.length = sizeof(struct acpi_resource);
  286. resource->res.data.irq.edge_level = link->irq.edge_level;
  287. resource->res.data.irq.active_high_low = link->irq.active_high_low;
  288. if (link->irq.edge_level == ACPI_EDGE_SENSITIVE)
  289. resource->res.data.irq.shared_exclusive = ACPI_EXCLUSIVE;
  290. else
  291. resource->res.data.irq.shared_exclusive = ACPI_SHARED;
  292. resource->res.data.irq.number_of_interrupts = 1;
  293. resource->res.data.irq.interrupts[0] = irq;
  294. break;
  295. case ACPI_RSTYPE_EXT_IRQ:
  296. resource->res.id = ACPI_RSTYPE_EXT_IRQ;
  297. resource->res.length = sizeof(struct acpi_resource);
  298. resource->res.data.extended_irq.producer_consumer = ACPI_CONSUMER;
  299. resource->res.data.extended_irq.edge_level = link->irq.edge_level;
  300. resource->res.data.extended_irq.active_high_low = link->irq.active_high_low;
  301. if (link->irq.edge_level == ACPI_EDGE_SENSITIVE)
  302. resource->res.data.irq.shared_exclusive = ACPI_EXCLUSIVE;
  303. else
  304. resource->res.data.irq.shared_exclusive = ACPI_SHARED;
  305. resource->res.data.extended_irq.number_of_interrupts = 1;
  306. resource->res.data.extended_irq.interrupts[0] = irq;
  307. /* ignore resource_source, it's optional */
  308. break;
  309. default:
  310. printk("ACPI BUG: resource_type %d\n", link->irq.resource_type);
  311. result = -EINVAL;
  312. goto end;
  313. }
  314. resource->end.id = ACPI_RSTYPE_END_TAG;
  315. /* Attempt to set the resource */
  316. status = acpi_set_current_resources(link->handle, &buffer);
  317. /* check for total failure */
  318. if (ACPI_FAILURE(status)) {
  319. ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _SRS\n"));
  320. result = -ENODEV;
  321. goto end;
  322. }
  323. /* Query _STA, set device->status */
  324. result = acpi_bus_get_status(link->device);
  325. if (result) {
  326. ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Unable to read status\n"));
  327. goto end;
  328. }
  329. if (!link->device->status.enabled) {
  330. printk(KERN_WARNING PREFIX
  331. "%s [%s] disabled and referenced, BIOS bug.\n",
  332. acpi_device_name(link->device),
  333. acpi_device_bid(link->device));
  334. }
  335. /* Query _CRS, set link->irq.active */
  336. result = acpi_pci_link_get_current(link);
  337. if (result) {
  338. goto end;
  339. }
  340. /*
  341. * Is current setting not what we set?
  342. * set link->irq.active
  343. */
  344. if (link->irq.active != irq) {
  345. /*
  346. * policy: when _CRS doesn't return what we just _SRS
  347. * assume _SRS worked and override _CRS value.
  348. */
  349. printk(KERN_WARNING PREFIX
  350. "%s [%s] BIOS reported IRQ %d, using IRQ %d\n",
  351. acpi_device_name(link->device),
  352. acpi_device_bid(link->device),
  353. link->irq.active, irq);
  354. link->irq.active = irq;
  355. }
  356. ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Set IRQ %d\n", link->irq.active));
  357. end:
  358. kfree(resource);
  359. return_VALUE(result);
  360. }
  361. /* --------------------------------------------------------------------------
  362. PCI Link IRQ Management
  363. -------------------------------------------------------------------------- */
  364. /*
  365. * "acpi_irq_balance" (default in APIC mode) enables ACPI to use PIC Interrupt
  366. * Link Devices to move the PIRQs around to minimize sharing.
  367. *
  368. * "acpi_irq_nobalance" (default in PIC mode) tells ACPI not to move any PIC IRQs
  369. * that the BIOS has already set to active. This is necessary because
  370. * ACPI has no automatic means of knowing what ISA IRQs are used. Note that
  371. * if the BIOS doesn't set a Link Device active, ACPI needs to program it
  372. * even if acpi_irq_nobalance is set.
  373. *
  374. * A tables of penalties avoids directing PCI interrupts to well known
  375. * ISA IRQs. Boot params are available to over-ride the default table:
  376. *
  377. * List interrupts that are free for PCI use.
  378. * acpi_irq_pci=n[,m]
  379. *
  380. * List interrupts that should not be used for PCI:
  381. * acpi_irq_isa=n[,m]
  382. *
  383. * Note that PCI IRQ routers have a list of possible IRQs,
  384. * which may not include the IRQs this table says are available.
  385. *
  386. * Since this heuristic can't tell the difference between a link
  387. * that no device will attach to, vs. a link which may be shared
  388. * by multiple active devices -- it is not optimal.
  389. *
  390. * If interrupt performance is that important, get an IO-APIC system
  391. * with a pin dedicated to each device. Or for that matter, an MSI
  392. * enabled system.
  393. */
  394. #define ACPI_MAX_IRQS 256
  395. #define ACPI_MAX_ISA_IRQ 16
  396. #define PIRQ_PENALTY_PCI_AVAILABLE (0)
  397. #define PIRQ_PENALTY_PCI_POSSIBLE (16*16)
  398. #define PIRQ_PENALTY_PCI_USING (16*16*16)
  399. #define PIRQ_PENALTY_ISA_TYPICAL (16*16*16*16)
  400. #define PIRQ_PENALTY_ISA_USED (16*16*16*16*16)
  401. #define PIRQ_PENALTY_ISA_ALWAYS (16*16*16*16*16*16)
  402. static int acpi_irq_penalty[ACPI_MAX_IRQS] = {
  403. PIRQ_PENALTY_ISA_ALWAYS, /* IRQ0 timer */
  404. PIRQ_PENALTY_ISA_ALWAYS, /* IRQ1 keyboard */
  405. PIRQ_PENALTY_ISA_ALWAYS, /* IRQ2 cascade */
  406. PIRQ_PENALTY_ISA_TYPICAL, /* IRQ3 serial */
  407. PIRQ_PENALTY_ISA_TYPICAL, /* IRQ4 serial */
  408. PIRQ_PENALTY_ISA_TYPICAL, /* IRQ5 sometimes SoundBlaster */
  409. PIRQ_PENALTY_ISA_TYPICAL, /* IRQ6 */
  410. PIRQ_PENALTY_ISA_TYPICAL, /* IRQ7 parallel, spurious */
  411. PIRQ_PENALTY_ISA_TYPICAL, /* IRQ8 rtc, sometimes */
  412. PIRQ_PENALTY_PCI_AVAILABLE, /* IRQ9 PCI, often acpi */
  413. PIRQ_PENALTY_PCI_AVAILABLE, /* IRQ10 PCI */
  414. PIRQ_PENALTY_PCI_AVAILABLE, /* IRQ11 PCI */
  415. PIRQ_PENALTY_ISA_USED, /* IRQ12 mouse */
  416. PIRQ_PENALTY_ISA_USED, /* IRQ13 fpe, sometimes */
  417. PIRQ_PENALTY_ISA_USED, /* IRQ14 ide0 */
  418. PIRQ_PENALTY_ISA_USED, /* IRQ15 ide1 */
  419. /* >IRQ15 */
  420. };
  421. int __init
  422. acpi_irq_penalty_init(void)
  423. {
  424. struct list_head *node = NULL;
  425. struct acpi_pci_link *link = NULL;
  426. int i = 0;
  427. ACPI_FUNCTION_TRACE("acpi_irq_penalty_init");
  428. /*
  429. * Update penalties to facilitate IRQ balancing.
  430. */
  431. list_for_each(node, &acpi_link.entries) {
  432. link = list_entry(node, struct acpi_pci_link, node);
  433. if (!link) {
  434. ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid link context\n"));
  435. continue;
  436. }
  437. /*
  438. * reflect the possible and active irqs in the penalty table --
  439. * useful for breaking ties.
  440. */
  441. if (link->irq.possible_count) {
  442. int penalty = PIRQ_PENALTY_PCI_POSSIBLE / link->irq.possible_count;
  443. for (i = 0; i < link->irq.possible_count; i++) {
  444. if (link->irq.possible[i] < ACPI_MAX_ISA_IRQ)
  445. acpi_irq_penalty[link->irq.possible[i]] += penalty;
  446. }
  447. } else if (link->irq.active) {
  448. acpi_irq_penalty[link->irq.active] += PIRQ_PENALTY_PCI_POSSIBLE;
  449. }
  450. }
  451. /* Add a penalty for the SCI */
  452. acpi_irq_penalty[acpi_fadt.sci_int] += PIRQ_PENALTY_PCI_USING;
  453. return_VALUE(0);
  454. }
  455. static int acpi_irq_balance; /* 0: static, 1: balance */
  456. static int acpi_pci_link_allocate(
  457. struct acpi_pci_link *link)
  458. {
  459. int irq;
  460. int i;
  461. ACPI_FUNCTION_TRACE("acpi_pci_link_allocate");
  462. if (link->irq.suspend_resume) {
  463. acpi_pci_link_set(link, link->irq.active);
  464. link->irq.suspend_resume = 0;
  465. }
  466. if (link->irq.initialized)
  467. return_VALUE(0);
  468. /*
  469. * search for active IRQ in list of possible IRQs.
  470. */
  471. for (i = 0; i < link->irq.possible_count; ++i) {
  472. if (link->irq.active == link->irq.possible[i])
  473. break;
  474. }
  475. /*
  476. * forget active IRQ that is not in possible list
  477. */
  478. if (i == link->irq.possible_count) {
  479. if (acpi_strict)
  480. printk(KERN_WARNING PREFIX "_CRS %d not found"
  481. " in _PRS\n", link->irq.active);
  482. link->irq.active = 0;
  483. }
  484. /*
  485. * if active found, use it; else pick entry from end of possible list.
  486. */
  487. if (link->irq.active) {
  488. irq = link->irq.active;
  489. } else {
  490. irq = link->irq.possible[link->irq.possible_count - 1];
  491. }
  492. if (acpi_irq_balance || !link->irq.active) {
  493. /*
  494. * Select the best IRQ. This is done in reverse to promote
  495. * the use of IRQs 9, 10, 11, and >15.
  496. */
  497. for (i = (link->irq.possible_count - 1); i >= 0; i--) {
  498. if (acpi_irq_penalty[irq] > acpi_irq_penalty[link->irq.possible[i]])
  499. irq = link->irq.possible[i];
  500. }
  501. }
  502. /* Attempt to enable the link device at this IRQ. */
  503. if (acpi_pci_link_set(link, irq)) {
  504. printk(PREFIX "Unable to set IRQ for %s [%s] (likely buggy ACPI BIOS).\n"
  505. "Try pci=noacpi or acpi=off\n",
  506. acpi_device_name(link->device),
  507. acpi_device_bid(link->device));
  508. return_VALUE(-ENODEV);
  509. } else {
  510. acpi_irq_penalty[link->irq.active] += PIRQ_PENALTY_PCI_USING;
  511. printk(PREFIX "%s [%s] enabled at IRQ %d\n",
  512. acpi_device_name(link->device),
  513. acpi_device_bid(link->device), link->irq.active);
  514. }
  515. link->irq.initialized = 1;
  516. return_VALUE(0);
  517. }
  518. /*
  519. * acpi_pci_link_get_irq
  520. * success: return IRQ >= 0
  521. * failure: return -1
  522. */
  523. int
  524. acpi_pci_link_get_irq (
  525. acpi_handle handle,
  526. int index,
  527. int *edge_level,
  528. int *active_high_low,
  529. char **name)
  530. {
  531. int result = 0;
  532. struct acpi_device *device = NULL;
  533. struct acpi_pci_link *link = NULL;
  534. ACPI_FUNCTION_TRACE("acpi_pci_link_get_irq");
  535. result = acpi_bus_get_device(handle, &device);
  536. if (result) {
  537. ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid link device\n"));
  538. return_VALUE(-1);
  539. }
  540. link = (struct acpi_pci_link *) acpi_driver_data(device);
  541. if (!link) {
  542. ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid link context\n"));
  543. return_VALUE(-1);
  544. }
  545. /* TBD: Support multiple index (IRQ) entries per Link Device */
  546. if (index) {
  547. ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid index %d\n", index));
  548. return_VALUE(-1);
  549. }
  550. if (acpi_pci_link_allocate(link))
  551. return_VALUE(-1);
  552. if (!link->irq.active) {
  553. ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Link active IRQ is 0!\n"));
  554. return_VALUE(-1);
  555. }
  556. if (edge_level) *edge_level = link->irq.edge_level;
  557. if (active_high_low) *active_high_low = link->irq.active_high_low;
  558. if (name) *name = acpi_device_bid(link->device);
  559. return_VALUE(link->irq.active);
  560. }
  561. /* --------------------------------------------------------------------------
  562. Driver Interface
  563. -------------------------------------------------------------------------- */
  564. static int
  565. acpi_pci_link_add (
  566. struct acpi_device *device)
  567. {
  568. int result = 0;
  569. struct acpi_pci_link *link = NULL;
  570. int i = 0;
  571. int found = 0;
  572. ACPI_FUNCTION_TRACE("acpi_pci_link_add");
  573. if (!device)
  574. return_VALUE(-EINVAL);
  575. link = kmalloc(sizeof(struct acpi_pci_link), GFP_KERNEL);
  576. if (!link)
  577. return_VALUE(-ENOMEM);
  578. memset(link, 0, sizeof(struct acpi_pci_link));
  579. link->device = device;
  580. link->handle = device->handle;
  581. strcpy(acpi_device_name(device), ACPI_PCI_LINK_DEVICE_NAME);
  582. strcpy(acpi_device_class(device), ACPI_PCI_LINK_CLASS);
  583. acpi_driver_data(device) = link;
  584. result = acpi_pci_link_get_possible(link);
  585. if (result)
  586. goto end;
  587. /* query and set link->irq.active */
  588. acpi_pci_link_get_current(link);
  589. printk(PREFIX "%s [%s] (IRQs", acpi_device_name(device),
  590. acpi_device_bid(device));
  591. for (i = 0; i < link->irq.possible_count; i++) {
  592. if (link->irq.active == link->irq.possible[i]) {
  593. printk(" *%d", link->irq.possible[i]);
  594. found = 1;
  595. }
  596. else
  597. printk(" %d", link->irq.possible[i]);
  598. }
  599. printk(")");
  600. if (!found)
  601. printk(" *%d", link->irq.active);
  602. if(!link->device->status.enabled)
  603. printk(", disabled.");
  604. printk("\n");
  605. /* TBD: Acquire/release lock */
  606. list_add_tail(&link->node, &acpi_link.entries);
  607. acpi_link.count++;
  608. end:
  609. /* disable all links -- to be activated on use */
  610. acpi_ut_evaluate_object(link->handle, "_DIS", 0, NULL);
  611. if (result)
  612. kfree(link);
  613. return_VALUE(result);
  614. }
  615. static int
  616. irqrouter_suspend(
  617. struct sys_device *dev,
  618. u32 state)
  619. {
  620. struct list_head *node = NULL;
  621. struct acpi_pci_link *link = NULL;
  622. ACPI_FUNCTION_TRACE("irqrouter_suspend");
  623. list_for_each(node, &acpi_link.entries) {
  624. link = list_entry(node, struct acpi_pci_link, node);
  625. if (!link) {
  626. ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid link context\n"));
  627. continue;
  628. }
  629. if (link->irq.active && link->irq.initialized)
  630. link->irq.suspend_resume = 1;
  631. }
  632. return_VALUE(0);
  633. }
  634. static int
  635. acpi_pci_link_remove (
  636. struct acpi_device *device,
  637. int type)
  638. {
  639. struct acpi_pci_link *link = NULL;
  640. ACPI_FUNCTION_TRACE("acpi_pci_link_remove");
  641. if (!device || !acpi_driver_data(device))
  642. return_VALUE(-EINVAL);
  643. link = (struct acpi_pci_link *) acpi_driver_data(device);
  644. /* TBD: Acquire/release lock */
  645. list_del(&link->node);
  646. kfree(link);
  647. return_VALUE(0);
  648. }
  649. /*
  650. * modify acpi_irq_penalty[] from cmdline
  651. */
  652. static int __init acpi_irq_penalty_update(char *str, int used)
  653. {
  654. int i;
  655. for (i = 0; i < 16; i++) {
  656. int retval;
  657. int irq;
  658. retval = get_option(&str,&irq);
  659. if (!retval)
  660. break; /* no number found */
  661. if (irq < 0)
  662. continue;
  663. if (irq >= ACPI_MAX_IRQS)
  664. continue;
  665. if (used)
  666. acpi_irq_penalty[irq] += PIRQ_PENALTY_ISA_USED;
  667. else
  668. acpi_irq_penalty[irq] = PIRQ_PENALTY_PCI_AVAILABLE;
  669. if (retval != 2) /* no next number */
  670. break;
  671. }
  672. return 1;
  673. }
  674. /*
  675. * We'd like PNP to call this routine for the
  676. * single ISA_USED value for each legacy device.
  677. * But instead it calls us with each POSSIBLE setting.
  678. * There is no ISA_POSSIBLE weight, so we simply use
  679. * the (small) PCI_USING penalty.
  680. */
  681. void acpi_penalize_isa_irq(int irq, int active)
  682. {
  683. if (active)
  684. acpi_irq_penalty[irq] += PIRQ_PENALTY_ISA_USED;
  685. else
  686. acpi_irq_penalty[irq] += PIRQ_PENALTY_PCI_USING;
  687. }
  688. /*
  689. * Over-ride default table to reserve additional IRQs for use by ISA
  690. * e.g. acpi_irq_isa=5
  691. * Useful for telling ACPI how not to interfere with your ISA sound card.
  692. */
  693. static int __init acpi_irq_isa(char *str)
  694. {
  695. return acpi_irq_penalty_update(str, 1);
  696. }
  697. __setup("acpi_irq_isa=", acpi_irq_isa);
  698. /*
  699. * Over-ride default table to free additional IRQs for use by PCI
  700. * e.g. acpi_irq_pci=7,15
  701. * Used for acpi_irq_balance to free up IRQs to reduce PCI IRQ sharing.
  702. */
  703. static int __init acpi_irq_pci(char *str)
  704. {
  705. return acpi_irq_penalty_update(str, 0);
  706. }
  707. __setup("acpi_irq_pci=", acpi_irq_pci);
  708. static int __init acpi_irq_nobalance_set(char *str)
  709. {
  710. acpi_irq_balance = 0;
  711. return 1;
  712. }
  713. __setup("acpi_irq_nobalance", acpi_irq_nobalance_set);
  714. int __init acpi_irq_balance_set(char *str)
  715. {
  716. acpi_irq_balance = 1;
  717. return 1;
  718. }
  719. __setup("acpi_irq_balance", acpi_irq_balance_set);
  720. static struct sysdev_class irqrouter_sysdev_class = {
  721. set_kset_name("irqrouter"),
  722. .suspend = irqrouter_suspend,
  723. };
  724. static struct sys_device device_irqrouter = {
  725. .id = 0,
  726. .cls = &irqrouter_sysdev_class,
  727. };
  728. static int __init irqrouter_init_sysfs(void)
  729. {
  730. int error;
  731. ACPI_FUNCTION_TRACE("irqrouter_init_sysfs");
  732. if (acpi_disabled || acpi_noirq)
  733. return_VALUE(0);
  734. error = sysdev_class_register(&irqrouter_sysdev_class);
  735. if (!error)
  736. error = sysdev_register(&device_irqrouter);
  737. return_VALUE(error);
  738. }
  739. device_initcall(irqrouter_init_sysfs);
  740. static int __init acpi_pci_link_init (void)
  741. {
  742. ACPI_FUNCTION_TRACE("acpi_pci_link_init");
  743. if (acpi_noirq)
  744. return_VALUE(0);
  745. acpi_link.count = 0;
  746. INIT_LIST_HEAD(&acpi_link.entries);
  747. if (acpi_bus_register_driver(&acpi_pci_link_driver) < 0)
  748. return_VALUE(-ENODEV);
  749. return_VALUE(0);
  750. }
  751. subsys_initcall(acpi_pci_link_init);