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