rsparser.c 26 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956
  1. /*
  2. * pnpacpi -- PnP ACPI driver
  3. *
  4. * Copyright (c) 2004 Matthieu Castet <castet.matthieu@free.fr>
  5. * Copyright (c) 2004 Li Shaohua <shaohua.li@intel.com>
  6. * Copyright (C) 2008 Hewlett-Packard Development Company, L.P.
  7. * Bjorn Helgaas <bjorn.helgaas@hp.com>
  8. *
  9. * This program is free software; you can redistribute it and/or modify it
  10. * under the terms of the GNU General Public License as published by the
  11. * Free Software Foundation; either version 2, or (at your option) any
  12. * later version.
  13. *
  14. * This program is distributed in the hope that it will be useful, but
  15. * WITHOUT ANY WARRANTY; without even the implied warranty of
  16. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17. * General Public License for more details.
  18. */
  19. #include <linux/kernel.h>
  20. #include <linux/acpi.h>
  21. #include <linux/pci.h>
  22. #include <linux/pnp.h>
  23. #include <linux/slab.h>
  24. #include "../base.h"
  25. #include "pnpacpi.h"
  26. static void decode_irq_flags(struct pnp_dev *dev, int flags, u8 *triggering,
  27. u8 *polarity, u8 *shareable)
  28. {
  29. switch (flags & (IORESOURCE_IRQ_LOWLEVEL | IORESOURCE_IRQ_HIGHLEVEL |
  30. IORESOURCE_IRQ_LOWEDGE | IORESOURCE_IRQ_HIGHEDGE)) {
  31. case IORESOURCE_IRQ_LOWLEVEL:
  32. *triggering = ACPI_LEVEL_SENSITIVE;
  33. *polarity = ACPI_ACTIVE_LOW;
  34. break;
  35. case IORESOURCE_IRQ_HIGHLEVEL:
  36. *triggering = ACPI_LEVEL_SENSITIVE;
  37. *polarity = ACPI_ACTIVE_HIGH;
  38. break;
  39. case IORESOURCE_IRQ_LOWEDGE:
  40. *triggering = ACPI_EDGE_SENSITIVE;
  41. *polarity = ACPI_ACTIVE_LOW;
  42. break;
  43. case IORESOURCE_IRQ_HIGHEDGE:
  44. *triggering = ACPI_EDGE_SENSITIVE;
  45. *polarity = ACPI_ACTIVE_HIGH;
  46. break;
  47. default:
  48. dev_err(&dev->dev, "can't encode invalid IRQ mode %#x\n",
  49. flags);
  50. *triggering = ACPI_EDGE_SENSITIVE;
  51. *polarity = ACPI_ACTIVE_HIGH;
  52. break;
  53. }
  54. if (flags & IORESOURCE_IRQ_SHAREABLE)
  55. *shareable = ACPI_SHARED;
  56. else
  57. *shareable = ACPI_EXCLUSIVE;
  58. }
  59. static int dma_flags(struct pnp_dev *dev, int type, int bus_master,
  60. int transfer)
  61. {
  62. int flags = 0;
  63. if (bus_master)
  64. flags |= IORESOURCE_DMA_MASTER;
  65. switch (type) {
  66. case ACPI_COMPATIBILITY:
  67. flags |= IORESOURCE_DMA_COMPATIBLE;
  68. break;
  69. case ACPI_TYPE_A:
  70. flags |= IORESOURCE_DMA_TYPEA;
  71. break;
  72. case ACPI_TYPE_B:
  73. flags |= IORESOURCE_DMA_TYPEB;
  74. break;
  75. case ACPI_TYPE_F:
  76. flags |= IORESOURCE_DMA_TYPEF;
  77. break;
  78. default:
  79. /* Set a default value ? */
  80. flags |= IORESOURCE_DMA_COMPATIBLE;
  81. dev_err(&dev->dev, "invalid DMA type %d\n", type);
  82. }
  83. switch (transfer) {
  84. case ACPI_TRANSFER_8:
  85. flags |= IORESOURCE_DMA_8BIT;
  86. break;
  87. case ACPI_TRANSFER_8_16:
  88. flags |= IORESOURCE_DMA_8AND16BIT;
  89. break;
  90. case ACPI_TRANSFER_16:
  91. flags |= IORESOURCE_DMA_16BIT;
  92. break;
  93. default:
  94. /* Set a default value ? */
  95. flags |= IORESOURCE_DMA_8AND16BIT;
  96. dev_err(&dev->dev, "invalid DMA transfer type %d\n", transfer);
  97. }
  98. return flags;
  99. }
  100. /*
  101. * Allocated Resources
  102. */
  103. static void pnpacpi_add_irqresource(struct pnp_dev *dev, struct resource *r)
  104. {
  105. if (!(r->flags & IORESOURCE_DISABLED))
  106. pcibios_penalize_isa_irq(r->start, 1);
  107. pnp_add_resource(dev, r);
  108. }
  109. /*
  110. * Device CSRs that do not appear in PCI config space should be described
  111. * via ACPI. This would normally be done with Address Space Descriptors
  112. * marked as "consumer-only," but old versions of Windows and Linux ignore
  113. * the producer/consumer flag, so HP invented a vendor-defined resource to
  114. * describe the location and size of CSR space.
  115. */
  116. static struct acpi_vendor_uuid hp_ccsr_uuid = {
  117. .subtype = 2,
  118. .data = { 0xf9, 0xad, 0xe9, 0x69, 0x4f, 0x92, 0x5f, 0xab, 0xf6, 0x4a,
  119. 0x24, 0xd2, 0x01, 0x37, 0x0e, 0xad },
  120. };
  121. static int vendor_resource_matches(struct pnp_dev *dev,
  122. struct acpi_resource_vendor_typed *vendor,
  123. struct acpi_vendor_uuid *match,
  124. int expected_len)
  125. {
  126. int uuid_len = sizeof(vendor->uuid);
  127. u8 uuid_subtype = vendor->uuid_subtype;
  128. u8 *uuid = vendor->uuid;
  129. int actual_len;
  130. /* byte_length includes uuid_subtype and uuid */
  131. actual_len = vendor->byte_length - uuid_len - 1;
  132. if (uuid_subtype == match->subtype &&
  133. uuid_len == sizeof(match->data) &&
  134. memcmp(uuid, match->data, uuid_len) == 0) {
  135. if (expected_len && expected_len != actual_len) {
  136. dev_err(&dev->dev,
  137. "wrong vendor descriptor size; expected %d, found %d bytes\n",
  138. expected_len, actual_len);
  139. return 0;
  140. }
  141. return 1;
  142. }
  143. return 0;
  144. }
  145. static void pnpacpi_parse_allocated_vendor(struct pnp_dev *dev,
  146. struct acpi_resource_vendor_typed *vendor)
  147. {
  148. if (vendor_resource_matches(dev, vendor, &hp_ccsr_uuid, 16)) {
  149. u64 start, length;
  150. memcpy(&start, vendor->byte_data, sizeof(start));
  151. memcpy(&length, vendor->byte_data + 8, sizeof(length));
  152. pnp_add_mem_resource(dev, start, start + length - 1, 0);
  153. }
  154. }
  155. static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res,
  156. void *data)
  157. {
  158. struct pnp_dev *dev = data;
  159. struct acpi_resource_dma *dma;
  160. struct acpi_resource_vendor_typed *vendor_typed;
  161. struct acpi_resource_gpio *gpio;
  162. struct resource_win win = {{0}, 0};
  163. struct resource *r = &win.res;
  164. int i, flags;
  165. if (acpi_dev_resource_address_space(res, &win)
  166. || acpi_dev_resource_ext_address_space(res, &win)) {
  167. pnp_add_resource(dev, &win.res);
  168. return AE_OK;
  169. }
  170. r->flags = 0;
  171. if (acpi_dev_resource_interrupt(res, 0, r)) {
  172. pnpacpi_add_irqresource(dev, r);
  173. for (i = 1; acpi_dev_resource_interrupt(res, i, r); i++)
  174. pnpacpi_add_irqresource(dev, r);
  175. if (i > 1) {
  176. /*
  177. * The IRQ encoder puts a single interrupt in each
  178. * descriptor, so if a _CRS descriptor has more than
  179. * one interrupt, we won't be able to re-encode it.
  180. */
  181. if (pnp_can_write(dev)) {
  182. dev_warn(&dev->dev,
  183. "multiple interrupts in _CRS descriptor; configuration can't be changed\n");
  184. dev->capabilities &= ~PNP_WRITE;
  185. }
  186. }
  187. return AE_OK;
  188. } else if (acpi_gpio_get_irq_resource(res, &gpio)) {
  189. /*
  190. * If the resource is GpioInt() type then extract the IRQ
  191. * from GPIO resource and fill it into IRQ resource type.
  192. */
  193. i = acpi_dev_gpio_irq_get(dev->data, 0);
  194. if (i >= 0) {
  195. flags = acpi_dev_irq_flags(gpio->triggering,
  196. gpio->polarity,
  197. gpio->sharable);
  198. } else {
  199. flags = IORESOURCE_DISABLED;
  200. }
  201. pnp_add_irq_resource(dev, i, flags);
  202. return AE_OK;
  203. } else if (r->flags & IORESOURCE_DISABLED) {
  204. pnp_add_irq_resource(dev, 0, IORESOURCE_DISABLED);
  205. return AE_OK;
  206. }
  207. switch (res->type) {
  208. case ACPI_RESOURCE_TYPE_MEMORY24:
  209. case ACPI_RESOURCE_TYPE_MEMORY32:
  210. case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
  211. if (acpi_dev_resource_memory(res, r))
  212. pnp_add_resource(dev, r);
  213. break;
  214. case ACPI_RESOURCE_TYPE_IO:
  215. case ACPI_RESOURCE_TYPE_FIXED_IO:
  216. if (acpi_dev_resource_io(res, r))
  217. pnp_add_resource(dev, r);
  218. break;
  219. case ACPI_RESOURCE_TYPE_DMA:
  220. dma = &res->data.dma;
  221. if (dma->channel_count > 0 && dma->channels[0] != (u8) -1)
  222. flags = dma_flags(dev, dma->type, dma->bus_master,
  223. dma->transfer);
  224. else
  225. flags = IORESOURCE_DISABLED;
  226. pnp_add_dma_resource(dev, dma->channels[0], flags);
  227. break;
  228. case ACPI_RESOURCE_TYPE_START_DEPENDENT:
  229. case ACPI_RESOURCE_TYPE_END_DEPENDENT:
  230. break;
  231. case ACPI_RESOURCE_TYPE_VENDOR:
  232. vendor_typed = &res->data.vendor_typed;
  233. pnpacpi_parse_allocated_vendor(dev, vendor_typed);
  234. break;
  235. case ACPI_RESOURCE_TYPE_END_TAG:
  236. break;
  237. case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
  238. break;
  239. case ACPI_RESOURCE_TYPE_SERIAL_BUS:
  240. /* serial bus connections (I2C/SPI/UART) are not pnp */
  241. break;
  242. default:
  243. dev_warn(&dev->dev, "unknown resource type %d in _CRS\n",
  244. res->type);
  245. return AE_ERROR;
  246. }
  247. return AE_OK;
  248. }
  249. int pnpacpi_parse_allocated_resource(struct pnp_dev *dev)
  250. {
  251. struct acpi_device *acpi_dev = dev->data;
  252. acpi_handle handle = acpi_dev->handle;
  253. acpi_status status;
  254. pnp_dbg(&dev->dev, "parse allocated resources\n");
  255. pnp_init_resources(dev);
  256. status = acpi_walk_resources(handle, METHOD_NAME__CRS,
  257. pnpacpi_allocated_resource, dev);
  258. if (ACPI_FAILURE(status)) {
  259. if (status != AE_NOT_FOUND)
  260. dev_err(&dev->dev, "can't evaluate _CRS: %d", status);
  261. return -EPERM;
  262. }
  263. return 0;
  264. }
  265. static __init void pnpacpi_parse_dma_option(struct pnp_dev *dev,
  266. unsigned int option_flags,
  267. struct acpi_resource_dma *p)
  268. {
  269. int i;
  270. unsigned char map = 0, flags;
  271. for (i = 0; i < p->channel_count; i++)
  272. map |= 1 << p->channels[i];
  273. flags = dma_flags(dev, p->type, p->bus_master, p->transfer);
  274. pnp_register_dma_resource(dev, option_flags, map, flags);
  275. }
  276. static __init void pnpacpi_parse_irq_option(struct pnp_dev *dev,
  277. unsigned int option_flags,
  278. struct acpi_resource_irq *p)
  279. {
  280. int i;
  281. pnp_irq_mask_t map;
  282. unsigned char flags;
  283. bitmap_zero(map.bits, PNP_IRQ_NR);
  284. for (i = 0; i < p->interrupt_count; i++)
  285. if (p->interrupts[i])
  286. __set_bit(p->interrupts[i], map.bits);
  287. flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->sharable);
  288. pnp_register_irq_resource(dev, option_flags, &map, flags);
  289. }
  290. static __init void pnpacpi_parse_ext_irq_option(struct pnp_dev *dev,
  291. unsigned int option_flags,
  292. struct acpi_resource_extended_irq *p)
  293. {
  294. int i;
  295. pnp_irq_mask_t map;
  296. unsigned char flags;
  297. bitmap_zero(map.bits, PNP_IRQ_NR);
  298. for (i = 0; i < p->interrupt_count; i++) {
  299. if (p->interrupts[i]) {
  300. if (p->interrupts[i] < PNP_IRQ_NR)
  301. __set_bit(p->interrupts[i], map.bits);
  302. else
  303. dev_err(&dev->dev,
  304. "ignoring IRQ %d option (too large for %d entry bitmap)\n",
  305. p->interrupts[i], PNP_IRQ_NR);
  306. }
  307. }
  308. flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->sharable);
  309. pnp_register_irq_resource(dev, option_flags, &map, flags);
  310. }
  311. static __init void pnpacpi_parse_port_option(struct pnp_dev *dev,
  312. unsigned int option_flags,
  313. struct acpi_resource_io *io)
  314. {
  315. unsigned char flags = 0;
  316. if (io->io_decode == ACPI_DECODE_16)
  317. flags = IORESOURCE_IO_16BIT_ADDR;
  318. pnp_register_port_resource(dev, option_flags, io->minimum, io->maximum,
  319. io->alignment, io->address_length, flags);
  320. }
  321. static __init void pnpacpi_parse_fixed_port_option(struct pnp_dev *dev,
  322. unsigned int option_flags,
  323. struct acpi_resource_fixed_io *io)
  324. {
  325. pnp_register_port_resource(dev, option_flags, io->address, io->address,
  326. 0, io->address_length, IORESOURCE_IO_FIXED);
  327. }
  328. static __init void pnpacpi_parse_mem24_option(struct pnp_dev *dev,
  329. unsigned int option_flags,
  330. struct acpi_resource_memory24 *p)
  331. {
  332. unsigned char flags = 0;
  333. if (p->write_protect == ACPI_READ_WRITE_MEMORY)
  334. flags = IORESOURCE_MEM_WRITEABLE;
  335. pnp_register_mem_resource(dev, option_flags, p->minimum, p->maximum,
  336. p->alignment, p->address_length, flags);
  337. }
  338. static __init void pnpacpi_parse_mem32_option(struct pnp_dev *dev,
  339. unsigned int option_flags,
  340. struct acpi_resource_memory32 *p)
  341. {
  342. unsigned char flags = 0;
  343. if (p->write_protect == ACPI_READ_WRITE_MEMORY)
  344. flags = IORESOURCE_MEM_WRITEABLE;
  345. pnp_register_mem_resource(dev, option_flags, p->minimum, p->maximum,
  346. p->alignment, p->address_length, flags);
  347. }
  348. static __init void pnpacpi_parse_fixed_mem32_option(struct pnp_dev *dev,
  349. unsigned int option_flags,
  350. struct acpi_resource_fixed_memory32 *p)
  351. {
  352. unsigned char flags = 0;
  353. if (p->write_protect == ACPI_READ_WRITE_MEMORY)
  354. flags = IORESOURCE_MEM_WRITEABLE;
  355. pnp_register_mem_resource(dev, option_flags, p->address, p->address,
  356. 0, p->address_length, flags);
  357. }
  358. static __init void pnpacpi_parse_address_option(struct pnp_dev *dev,
  359. unsigned int option_flags,
  360. struct acpi_resource *r)
  361. {
  362. struct acpi_resource_address64 addr, *p = &addr;
  363. acpi_status status;
  364. unsigned char flags = 0;
  365. status = acpi_resource_to_address64(r, p);
  366. if (ACPI_FAILURE(status)) {
  367. dev_warn(&dev->dev, "can't convert resource type %d\n",
  368. r->type);
  369. return;
  370. }
  371. if (p->resource_type == ACPI_MEMORY_RANGE) {
  372. if (p->info.mem.write_protect == ACPI_READ_WRITE_MEMORY)
  373. flags = IORESOURCE_MEM_WRITEABLE;
  374. pnp_register_mem_resource(dev, option_flags, p->address.minimum,
  375. p->address.minimum, 0, p->address.address_length,
  376. flags);
  377. } else if (p->resource_type == ACPI_IO_RANGE)
  378. pnp_register_port_resource(dev, option_flags, p->address.minimum,
  379. p->address.minimum, 0, p->address.address_length,
  380. IORESOURCE_IO_FIXED);
  381. }
  382. static __init void pnpacpi_parse_ext_address_option(struct pnp_dev *dev,
  383. unsigned int option_flags,
  384. struct acpi_resource *r)
  385. {
  386. struct acpi_resource_extended_address64 *p = &r->data.ext_address64;
  387. unsigned char flags = 0;
  388. if (p->resource_type == ACPI_MEMORY_RANGE) {
  389. if (p->info.mem.write_protect == ACPI_READ_WRITE_MEMORY)
  390. flags = IORESOURCE_MEM_WRITEABLE;
  391. pnp_register_mem_resource(dev, option_flags, p->address.minimum,
  392. p->address.minimum, 0, p->address.address_length,
  393. flags);
  394. } else if (p->resource_type == ACPI_IO_RANGE)
  395. pnp_register_port_resource(dev, option_flags, p->address.minimum,
  396. p->address.minimum, 0, p->address.address_length,
  397. IORESOURCE_IO_FIXED);
  398. }
  399. struct acpipnp_parse_option_s {
  400. struct pnp_dev *dev;
  401. unsigned int option_flags;
  402. };
  403. static __init acpi_status pnpacpi_option_resource(struct acpi_resource *res,
  404. void *data)
  405. {
  406. int priority;
  407. struct acpipnp_parse_option_s *parse_data = data;
  408. struct pnp_dev *dev = parse_data->dev;
  409. unsigned int option_flags = parse_data->option_flags;
  410. switch (res->type) {
  411. case ACPI_RESOURCE_TYPE_IRQ:
  412. pnpacpi_parse_irq_option(dev, option_flags, &res->data.irq);
  413. break;
  414. case ACPI_RESOURCE_TYPE_DMA:
  415. pnpacpi_parse_dma_option(dev, option_flags, &res->data.dma);
  416. break;
  417. case ACPI_RESOURCE_TYPE_START_DEPENDENT:
  418. switch (res->data.start_dpf.compatibility_priority) {
  419. case ACPI_GOOD_CONFIGURATION:
  420. priority = PNP_RES_PRIORITY_PREFERRED;
  421. break;
  422. case ACPI_ACCEPTABLE_CONFIGURATION:
  423. priority = PNP_RES_PRIORITY_ACCEPTABLE;
  424. break;
  425. case ACPI_SUB_OPTIMAL_CONFIGURATION:
  426. priority = PNP_RES_PRIORITY_FUNCTIONAL;
  427. break;
  428. default:
  429. priority = PNP_RES_PRIORITY_INVALID;
  430. break;
  431. }
  432. parse_data->option_flags = pnp_new_dependent_set(dev, priority);
  433. break;
  434. case ACPI_RESOURCE_TYPE_END_DEPENDENT:
  435. parse_data->option_flags = 0;
  436. break;
  437. case ACPI_RESOURCE_TYPE_IO:
  438. pnpacpi_parse_port_option(dev, option_flags, &res->data.io);
  439. break;
  440. case ACPI_RESOURCE_TYPE_FIXED_IO:
  441. pnpacpi_parse_fixed_port_option(dev, option_flags,
  442. &res->data.fixed_io);
  443. break;
  444. case ACPI_RESOURCE_TYPE_VENDOR:
  445. case ACPI_RESOURCE_TYPE_END_TAG:
  446. break;
  447. case ACPI_RESOURCE_TYPE_MEMORY24:
  448. pnpacpi_parse_mem24_option(dev, option_flags,
  449. &res->data.memory24);
  450. break;
  451. case ACPI_RESOURCE_TYPE_MEMORY32:
  452. pnpacpi_parse_mem32_option(dev, option_flags,
  453. &res->data.memory32);
  454. break;
  455. case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
  456. pnpacpi_parse_fixed_mem32_option(dev, option_flags,
  457. &res->data.fixed_memory32);
  458. break;
  459. case ACPI_RESOURCE_TYPE_ADDRESS16:
  460. case ACPI_RESOURCE_TYPE_ADDRESS32:
  461. case ACPI_RESOURCE_TYPE_ADDRESS64:
  462. pnpacpi_parse_address_option(dev, option_flags, res);
  463. break;
  464. case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
  465. pnpacpi_parse_ext_address_option(dev, option_flags, res);
  466. break;
  467. case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
  468. pnpacpi_parse_ext_irq_option(dev, option_flags,
  469. &res->data.extended_irq);
  470. break;
  471. case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
  472. break;
  473. default:
  474. dev_warn(&dev->dev, "unknown resource type %d in _PRS\n",
  475. res->type);
  476. return AE_ERROR;
  477. }
  478. return AE_OK;
  479. }
  480. int __init pnpacpi_parse_resource_option_data(struct pnp_dev *dev)
  481. {
  482. struct acpi_device *acpi_dev = dev->data;
  483. acpi_handle handle = acpi_dev->handle;
  484. acpi_status status;
  485. struct acpipnp_parse_option_s parse_data;
  486. pnp_dbg(&dev->dev, "parse resource options\n");
  487. parse_data.dev = dev;
  488. parse_data.option_flags = 0;
  489. status = acpi_walk_resources(handle, METHOD_NAME__PRS,
  490. pnpacpi_option_resource, &parse_data);
  491. if (ACPI_FAILURE(status)) {
  492. if (status != AE_NOT_FOUND)
  493. dev_err(&dev->dev, "can't evaluate _PRS: %d", status);
  494. return -EPERM;
  495. }
  496. return 0;
  497. }
  498. static int pnpacpi_supported_resource(struct acpi_resource *res)
  499. {
  500. switch (res->type) {
  501. case ACPI_RESOURCE_TYPE_IRQ:
  502. case ACPI_RESOURCE_TYPE_DMA:
  503. case ACPI_RESOURCE_TYPE_IO:
  504. case ACPI_RESOURCE_TYPE_FIXED_IO:
  505. case ACPI_RESOURCE_TYPE_MEMORY24:
  506. case ACPI_RESOURCE_TYPE_MEMORY32:
  507. case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
  508. case ACPI_RESOURCE_TYPE_ADDRESS16:
  509. case ACPI_RESOURCE_TYPE_ADDRESS32:
  510. case ACPI_RESOURCE_TYPE_ADDRESS64:
  511. case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
  512. case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
  513. return 1;
  514. }
  515. return 0;
  516. }
  517. /*
  518. * Set resource
  519. */
  520. static acpi_status pnpacpi_count_resources(struct acpi_resource *res,
  521. void *data)
  522. {
  523. int *res_cnt = data;
  524. if (pnpacpi_supported_resource(res))
  525. (*res_cnt)++;
  526. return AE_OK;
  527. }
  528. static acpi_status pnpacpi_type_resources(struct acpi_resource *res, void *data)
  529. {
  530. struct acpi_resource **resource = data;
  531. if (pnpacpi_supported_resource(res)) {
  532. (*resource)->type = res->type;
  533. (*resource)->length = sizeof(struct acpi_resource);
  534. if (res->type == ACPI_RESOURCE_TYPE_IRQ)
  535. (*resource)->data.irq.descriptor_length =
  536. res->data.irq.descriptor_length;
  537. (*resource)++;
  538. }
  539. return AE_OK;
  540. }
  541. int pnpacpi_build_resource_template(struct pnp_dev *dev,
  542. struct acpi_buffer *buffer)
  543. {
  544. struct acpi_device *acpi_dev = dev->data;
  545. acpi_handle handle = acpi_dev->handle;
  546. struct acpi_resource *resource;
  547. int res_cnt = 0;
  548. acpi_status status;
  549. status = acpi_walk_resources(handle, METHOD_NAME__CRS,
  550. pnpacpi_count_resources, &res_cnt);
  551. if (ACPI_FAILURE(status)) {
  552. dev_err(&dev->dev, "can't evaluate _CRS: %d\n", status);
  553. return -EINVAL;
  554. }
  555. if (!res_cnt)
  556. return -EINVAL;
  557. buffer->length = sizeof(struct acpi_resource) * (res_cnt + 1) + 1;
  558. buffer->pointer = kzalloc(buffer->length - 1, GFP_KERNEL);
  559. if (!buffer->pointer)
  560. return -ENOMEM;
  561. resource = (struct acpi_resource *)buffer->pointer;
  562. status = acpi_walk_resources(handle, METHOD_NAME__CRS,
  563. pnpacpi_type_resources, &resource);
  564. if (ACPI_FAILURE(status)) {
  565. kfree(buffer->pointer);
  566. dev_err(&dev->dev, "can't evaluate _CRS: %d\n", status);
  567. return -EINVAL;
  568. }
  569. /* resource will pointer the end resource now */
  570. resource->type = ACPI_RESOURCE_TYPE_END_TAG;
  571. resource->length = sizeof(struct acpi_resource);
  572. return 0;
  573. }
  574. static void pnpacpi_encode_irq(struct pnp_dev *dev,
  575. struct acpi_resource *resource,
  576. struct resource *p)
  577. {
  578. struct acpi_resource_irq *irq = &resource->data.irq;
  579. u8 triggering, polarity, shareable;
  580. if (!pnp_resource_enabled(p)) {
  581. irq->interrupt_count = 0;
  582. pnp_dbg(&dev->dev, " encode irq (%s)\n",
  583. p ? "disabled" : "missing");
  584. return;
  585. }
  586. decode_irq_flags(dev, p->flags, &triggering, &polarity, &shareable);
  587. irq->triggering = triggering;
  588. irq->polarity = polarity;
  589. irq->sharable = shareable;
  590. irq->interrupt_count = 1;
  591. irq->interrupts[0] = p->start;
  592. pnp_dbg(&dev->dev, " encode irq %d %s %s %s (%d-byte descriptor)\n",
  593. (int) p->start,
  594. triggering == ACPI_LEVEL_SENSITIVE ? "level" : "edge",
  595. polarity == ACPI_ACTIVE_LOW ? "low" : "high",
  596. irq->sharable == ACPI_SHARED ? "shared" : "exclusive",
  597. irq->descriptor_length);
  598. }
  599. static void pnpacpi_encode_ext_irq(struct pnp_dev *dev,
  600. struct acpi_resource *resource,
  601. struct resource *p)
  602. {
  603. struct acpi_resource_extended_irq *extended_irq = &resource->data.extended_irq;
  604. u8 triggering, polarity, shareable;
  605. if (!pnp_resource_enabled(p)) {
  606. extended_irq->interrupt_count = 0;
  607. pnp_dbg(&dev->dev, " encode extended irq (%s)\n",
  608. p ? "disabled" : "missing");
  609. return;
  610. }
  611. decode_irq_flags(dev, p->flags, &triggering, &polarity, &shareable);
  612. extended_irq->producer_consumer = ACPI_CONSUMER;
  613. extended_irq->triggering = triggering;
  614. extended_irq->polarity = polarity;
  615. extended_irq->sharable = shareable;
  616. extended_irq->interrupt_count = 1;
  617. extended_irq->interrupts[0] = p->start;
  618. pnp_dbg(&dev->dev, " encode irq %d %s %s %s\n", (int) p->start,
  619. triggering == ACPI_LEVEL_SENSITIVE ? "level" : "edge",
  620. polarity == ACPI_ACTIVE_LOW ? "low" : "high",
  621. extended_irq->sharable == ACPI_SHARED ? "shared" : "exclusive");
  622. }
  623. static void pnpacpi_encode_dma(struct pnp_dev *dev,
  624. struct acpi_resource *resource,
  625. struct resource *p)
  626. {
  627. struct acpi_resource_dma *dma = &resource->data.dma;
  628. if (!pnp_resource_enabled(p)) {
  629. dma->channel_count = 0;
  630. pnp_dbg(&dev->dev, " encode dma (%s)\n",
  631. p ? "disabled" : "missing");
  632. return;
  633. }
  634. /* Note: pnp_assign_dma will copy pnp_dma->flags into p->flags */
  635. switch (p->flags & IORESOURCE_DMA_SPEED_MASK) {
  636. case IORESOURCE_DMA_TYPEA:
  637. dma->type = ACPI_TYPE_A;
  638. break;
  639. case IORESOURCE_DMA_TYPEB:
  640. dma->type = ACPI_TYPE_B;
  641. break;
  642. case IORESOURCE_DMA_TYPEF:
  643. dma->type = ACPI_TYPE_F;
  644. break;
  645. default:
  646. dma->type = ACPI_COMPATIBILITY;
  647. }
  648. switch (p->flags & IORESOURCE_DMA_TYPE_MASK) {
  649. case IORESOURCE_DMA_8BIT:
  650. dma->transfer = ACPI_TRANSFER_8;
  651. break;
  652. case IORESOURCE_DMA_8AND16BIT:
  653. dma->transfer = ACPI_TRANSFER_8_16;
  654. break;
  655. default:
  656. dma->transfer = ACPI_TRANSFER_16;
  657. }
  658. dma->bus_master = !!(p->flags & IORESOURCE_DMA_MASTER);
  659. dma->channel_count = 1;
  660. dma->channels[0] = p->start;
  661. pnp_dbg(&dev->dev, " encode dma %d "
  662. "type %#x transfer %#x master %d\n",
  663. (int) p->start, dma->type, dma->transfer, dma->bus_master);
  664. }
  665. static void pnpacpi_encode_io(struct pnp_dev *dev,
  666. struct acpi_resource *resource,
  667. struct resource *p)
  668. {
  669. struct acpi_resource_io *io = &resource->data.io;
  670. if (pnp_resource_enabled(p)) {
  671. /* Note: pnp_assign_port copies pnp_port->flags into p->flags */
  672. io->io_decode = (p->flags & IORESOURCE_IO_16BIT_ADDR) ?
  673. ACPI_DECODE_16 : ACPI_DECODE_10;
  674. io->minimum = p->start;
  675. io->maximum = p->end;
  676. io->alignment = 0; /* Correct? */
  677. io->address_length = resource_size(p);
  678. } else {
  679. io->minimum = 0;
  680. io->address_length = 0;
  681. }
  682. pnp_dbg(&dev->dev, " encode io %#x-%#x decode %#x\n", io->minimum,
  683. io->minimum + io->address_length - 1, io->io_decode);
  684. }
  685. static void pnpacpi_encode_fixed_io(struct pnp_dev *dev,
  686. struct acpi_resource *resource,
  687. struct resource *p)
  688. {
  689. struct acpi_resource_fixed_io *fixed_io = &resource->data.fixed_io;
  690. if (pnp_resource_enabled(p)) {
  691. fixed_io->address = p->start;
  692. fixed_io->address_length = resource_size(p);
  693. } else {
  694. fixed_io->address = 0;
  695. fixed_io->address_length = 0;
  696. }
  697. pnp_dbg(&dev->dev, " encode fixed_io %#x-%#x\n", fixed_io->address,
  698. fixed_io->address + fixed_io->address_length - 1);
  699. }
  700. static void pnpacpi_encode_mem24(struct pnp_dev *dev,
  701. struct acpi_resource *resource,
  702. struct resource *p)
  703. {
  704. struct acpi_resource_memory24 *memory24 = &resource->data.memory24;
  705. if (pnp_resource_enabled(p)) {
  706. /* Note: pnp_assign_mem copies pnp_mem->flags into p->flags */
  707. memory24->write_protect = p->flags & IORESOURCE_MEM_WRITEABLE ?
  708. ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
  709. memory24->minimum = p->start;
  710. memory24->maximum = p->end;
  711. memory24->alignment = 0;
  712. memory24->address_length = resource_size(p);
  713. } else {
  714. memory24->minimum = 0;
  715. memory24->address_length = 0;
  716. }
  717. pnp_dbg(&dev->dev, " encode mem24 %#x-%#x write_protect %#x\n",
  718. memory24->minimum,
  719. memory24->minimum + memory24->address_length - 1,
  720. memory24->write_protect);
  721. }
  722. static void pnpacpi_encode_mem32(struct pnp_dev *dev,
  723. struct acpi_resource *resource,
  724. struct resource *p)
  725. {
  726. struct acpi_resource_memory32 *memory32 = &resource->data.memory32;
  727. if (pnp_resource_enabled(p)) {
  728. memory32->write_protect = p->flags & IORESOURCE_MEM_WRITEABLE ?
  729. ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
  730. memory32->minimum = p->start;
  731. memory32->maximum = p->end;
  732. memory32->alignment = 0;
  733. memory32->address_length = resource_size(p);
  734. } else {
  735. memory32->minimum = 0;
  736. memory32->alignment = 0;
  737. }
  738. pnp_dbg(&dev->dev, " encode mem32 %#x-%#x write_protect %#x\n",
  739. memory32->minimum,
  740. memory32->minimum + memory32->address_length - 1,
  741. memory32->write_protect);
  742. }
  743. static void pnpacpi_encode_fixed_mem32(struct pnp_dev *dev,
  744. struct acpi_resource *resource,
  745. struct resource *p)
  746. {
  747. struct acpi_resource_fixed_memory32 *fixed_memory32 = &resource->data.fixed_memory32;
  748. if (pnp_resource_enabled(p)) {
  749. fixed_memory32->write_protect =
  750. p->flags & IORESOURCE_MEM_WRITEABLE ?
  751. ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
  752. fixed_memory32->address = p->start;
  753. fixed_memory32->address_length = resource_size(p);
  754. } else {
  755. fixed_memory32->address = 0;
  756. fixed_memory32->address_length = 0;
  757. }
  758. pnp_dbg(&dev->dev, " encode fixed_mem32 %#x-%#x write_protect %#x\n",
  759. fixed_memory32->address,
  760. fixed_memory32->address + fixed_memory32->address_length - 1,
  761. fixed_memory32->write_protect);
  762. }
  763. int pnpacpi_encode_resources(struct pnp_dev *dev, struct acpi_buffer *buffer)
  764. {
  765. int i = 0;
  766. /* pnpacpi_build_resource_template allocates extra mem */
  767. int res_cnt = (buffer->length - 1) / sizeof(struct acpi_resource) - 1;
  768. struct acpi_resource *resource = buffer->pointer;
  769. unsigned int port = 0, irq = 0, dma = 0, mem = 0;
  770. pnp_dbg(&dev->dev, "encode %d resources\n", res_cnt);
  771. while (i < res_cnt) {
  772. switch (resource->type) {
  773. case ACPI_RESOURCE_TYPE_IRQ:
  774. pnpacpi_encode_irq(dev, resource,
  775. pnp_get_resource(dev, IORESOURCE_IRQ, irq));
  776. irq++;
  777. break;
  778. case ACPI_RESOURCE_TYPE_DMA:
  779. pnpacpi_encode_dma(dev, resource,
  780. pnp_get_resource(dev, IORESOURCE_DMA, dma));
  781. dma++;
  782. break;
  783. case ACPI_RESOURCE_TYPE_IO:
  784. pnpacpi_encode_io(dev, resource,
  785. pnp_get_resource(dev, IORESOURCE_IO, port));
  786. port++;
  787. break;
  788. case ACPI_RESOURCE_TYPE_FIXED_IO:
  789. pnpacpi_encode_fixed_io(dev, resource,
  790. pnp_get_resource(dev, IORESOURCE_IO, port));
  791. port++;
  792. break;
  793. case ACPI_RESOURCE_TYPE_MEMORY24:
  794. pnpacpi_encode_mem24(dev, resource,
  795. pnp_get_resource(dev, IORESOURCE_MEM, mem));
  796. mem++;
  797. break;
  798. case ACPI_RESOURCE_TYPE_MEMORY32:
  799. pnpacpi_encode_mem32(dev, resource,
  800. pnp_get_resource(dev, IORESOURCE_MEM, mem));
  801. mem++;
  802. break;
  803. case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
  804. pnpacpi_encode_fixed_mem32(dev, resource,
  805. pnp_get_resource(dev, IORESOURCE_MEM, mem));
  806. mem++;
  807. break;
  808. case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
  809. pnpacpi_encode_ext_irq(dev, resource,
  810. pnp_get_resource(dev, IORESOURCE_IRQ, irq));
  811. irq++;
  812. break;
  813. case ACPI_RESOURCE_TYPE_START_DEPENDENT:
  814. case ACPI_RESOURCE_TYPE_END_DEPENDENT:
  815. case ACPI_RESOURCE_TYPE_VENDOR:
  816. case ACPI_RESOURCE_TYPE_END_TAG:
  817. case ACPI_RESOURCE_TYPE_ADDRESS16:
  818. case ACPI_RESOURCE_TYPE_ADDRESS32:
  819. case ACPI_RESOURCE_TYPE_ADDRESS64:
  820. case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
  821. case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
  822. default: /* other type */
  823. dev_warn(&dev->dev,
  824. "can't encode unknown resource type %d\n",
  825. resource->type);
  826. return -EINVAL;
  827. }
  828. resource++;
  829. i++;
  830. }
  831. return 0;
  832. }