?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.2.1
[linux/fpc-iii.git] / drivers / pnp / pnpacpi / rsparser.c
blob05796495be0e4ada9ba9b2995be1698c79fed1e8
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 * 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>
26 #include <linux/pnp.h>
27 #include <linux/slab.h>
28 #include "../base.h"
29 #include "pnpacpi.h"
30
31 static void decode_irq_flags(struct pnp_dev *dev, int flags, u8 *triggering,
32 u8 *polarity, u8 *shareable)
33 {
34 switch (flags & (IORESOURCE_IRQ_LOWLEVEL | IORESOURCE_IRQ_HIGHLEVEL |
35 IORESOURCE_IRQ_LOWEDGE | IORESOURCE_IRQ_HIGHEDGE)) {
36 case IORESOURCE_IRQ_LOWLEVEL:
37 *triggering = ACPI_LEVEL_SENSITIVE;
38 *polarity = ACPI_ACTIVE_LOW;
39 break;
40 case IORESOURCE_IRQ_HIGHLEVEL:
41 *triggering = ACPI_LEVEL_SENSITIVE;
42 *polarity = ACPI_ACTIVE_HIGH;
43 break;
44 case IORESOURCE_IRQ_LOWEDGE:
45 *triggering = ACPI_EDGE_SENSITIVE;
46 *polarity = ACPI_ACTIVE_LOW;
47 break;
48 case IORESOURCE_IRQ_HIGHEDGE:
49 *triggering = ACPI_EDGE_SENSITIVE;
50 *polarity = ACPI_ACTIVE_HIGH;
51 break;
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;
58 }
59
60 if (flags & IORESOURCE_IRQ_SHAREABLE)
61 *shareable = ACPI_SHARED;
62 else
63 *shareable = ACPI_EXCLUSIVE;
64 }
65
66 static int dma_flags(struct pnp_dev *dev, int type, int bus_master,
67 int transfer)
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;
89 dev_err(&dev->dev, "invalid DMA type %d\n", type);
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;
104 dev_err(&dev->dev, "invalid DMA transfer type %d\n", transfer);
105 }
106
107 return flags;
108 }
109
110 /*
111 * Allocated Resources
112 */
113
114 static 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);
118
119 pnp_add_resource(dev, r);
120 }
121
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 */
129 static 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
135 static 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
164 static 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
177 static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res,
178 void *data)
179 {
180 struct pnp_dev *dev = data;
181 struct acpi_resource_dma *dma;
182 struct acpi_resource_vendor_typed *vendor_typed;
183 struct resource_win win = {{0}, 0};
184 struct resource *r = &win.res;
185 int i, flags;
186
187 if (acpi_dev_resource_address_space(res, &win)
188 || acpi_dev_resource_ext_address_space(res, &win)) {
189 pnp_add_resource(dev, &win.res);
190 return AE_OK;
191 }
192
193 r->flags = 0;
194 if (acpi_dev_resource_interrupt(res, 0, r)) {
195 pnpacpi_add_irqresource(dev, r);
196 for (i = 1; acpi_dev_resource_interrupt(res, i, r); i++)
197 pnpacpi_add_irqresource(dev, r);
198
199 if (i > 1) {
200 /*
201 * The IRQ encoder puts a single interrupt in each
202 * descriptor, so if a _CRS descriptor has more than
203 * one interrupt, we won't be able to re-encode it.
204 */
205 if (pnp_can_write(dev)) {
206 dev_warn(&dev->dev, "multiple interrupts in "
207 "_CRS descriptor; configuration can't "
208 "be changed\n");
209 dev->capabilities &= ~PNP_WRITE;
210 }
211 }
212 return AE_OK;
213 } else if (r->flags & IORESOURCE_DISABLED) {
214 pnp_add_irq_resource(dev, 0, IORESOURCE_DISABLED);
215 return AE_OK;
216 }
217
218 switch (res->type) {
219 case ACPI_RESOURCE_TYPE_MEMORY24:
220 case ACPI_RESOURCE_TYPE_MEMORY32:
221 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
222 if (acpi_dev_resource_memory(res, r))
223 pnp_add_resource(dev, r);
224 break;
225 case ACPI_RESOURCE_TYPE_IO:
226 case ACPI_RESOURCE_TYPE_FIXED_IO:
227 if (acpi_dev_resource_io(res, r))
228 pnp_add_resource(dev, r);
229 break;
230 case ACPI_RESOURCE_TYPE_DMA:
231 dma = &res->data.dma;
232 if (dma->channel_count > 0 && dma->channels[0] != (u8) -1)
233 flags = dma_flags(dev, dma->type, dma->bus_master,
234 dma->transfer);
235 else
236 flags = IORESOURCE_DISABLED;
237 pnp_add_dma_resource(dev, dma->channels[0], flags);
238 break;
239
240 case ACPI_RESOURCE_TYPE_START_DEPENDENT:
241 case ACPI_RESOURCE_TYPE_END_DEPENDENT:
242 break;
243
244 case ACPI_RESOURCE_TYPE_VENDOR:
245 vendor_typed = &res->data.vendor_typed;
246 pnpacpi_parse_allocated_vendor(dev, vendor_typed);
247 break;
248
249 case ACPI_RESOURCE_TYPE_END_TAG:
250 break;
251
252 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
253 break;
254
255 default:
256 dev_warn(&dev->dev, "unknown resource type %d in _CRS\n",
257 res->type);
258 return AE_ERROR;
259 }
260
261 return AE_OK;
262 }
263
264 int pnpacpi_parse_allocated_resource(struct pnp_dev *dev)
265 {
266 struct acpi_device *acpi_dev = dev->data;
267 acpi_handle handle = acpi_dev->handle;
268 acpi_status status;
269
270 pnp_dbg(&dev->dev, "parse allocated resources\n");
271
272 pnp_init_resources(dev);
273
274 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
275 pnpacpi_allocated_resource, dev);
276
277 if (ACPI_FAILURE(status)) {
278 if (status != AE_NOT_FOUND)
279 dev_err(&dev->dev, "can't evaluate _CRS: %d", status);
280 return -EPERM;
281 }
282 return 0;
283 }
284
285 static __init void pnpacpi_parse_dma_option(struct pnp_dev *dev,
286 unsigned int option_flags,
287 struct acpi_resource_dma *p)
288 {
289 int i;
290 unsigned char map = 0, flags;
291
292 for (i = 0; i < p->channel_count; i++)
293 map |= 1 << p->channels[i];
294
295 flags = dma_flags(dev, p->type, p->bus_master, p->transfer);
296 pnp_register_dma_resource(dev, option_flags, map, flags);
297 }
298
299 static __init void pnpacpi_parse_irq_option(struct pnp_dev *dev,
300 unsigned int option_flags,
301 struct acpi_resource_irq *p)
302 {
303 int i;
304 pnp_irq_mask_t map;
305 unsigned char flags;
306
307 bitmap_zero(map.bits, PNP_IRQ_NR);
308 for (i = 0; i < p->interrupt_count; i++)
309 if (p->interrupts[i])
310 __set_bit(p->interrupts[i], map.bits);
311
312 flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->sharable);
313 pnp_register_irq_resource(dev, option_flags, &map, flags);
314 }
315
316 static __init void pnpacpi_parse_ext_irq_option(struct pnp_dev *dev,
317 unsigned int option_flags,
318 struct acpi_resource_extended_irq *p)
319 {
320 int i;
321 pnp_irq_mask_t map;
322 unsigned char flags;
323
324 bitmap_zero(map.bits, PNP_IRQ_NR);
325 for (i = 0; i < p->interrupt_count; i++) {
326 if (p->interrupts[i]) {
327 if (p->interrupts[i] < PNP_IRQ_NR)
328 __set_bit(p->interrupts[i], map.bits);
329 else
330 dev_err(&dev->dev, "ignoring IRQ %d option "
331 "(too large for %d entry bitmap)\n",
332 p->interrupts[i], PNP_IRQ_NR);
333 }
334 }
335
336 flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->sharable);
337 pnp_register_irq_resource(dev, option_flags, &map, flags);
338 }
339
340 static __init void pnpacpi_parse_port_option(struct pnp_dev *dev,
341 unsigned int option_flags,
342 struct acpi_resource_io *io)
343 {
344 unsigned char flags = 0;
345
346 if (io->io_decode == ACPI_DECODE_16)
347 flags = IORESOURCE_IO_16BIT_ADDR;
348 pnp_register_port_resource(dev, option_flags, io->minimum, io->maximum,
349 io->alignment, io->address_length, flags);
350 }
351
352 static __init void pnpacpi_parse_fixed_port_option(struct pnp_dev *dev,
353 unsigned int option_flags,
354 struct acpi_resource_fixed_io *io)
355 {
356 pnp_register_port_resource(dev, option_flags, io->address, io->address,
357 0, io->address_length, IORESOURCE_IO_FIXED);
358 }
359
360 static __init void pnpacpi_parse_mem24_option(struct pnp_dev *dev,
361 unsigned int option_flags,
362 struct acpi_resource_memory24 *p)
363 {
364 unsigned char flags = 0;
365
366 if (p->write_protect == ACPI_READ_WRITE_MEMORY)
367 flags = IORESOURCE_MEM_WRITEABLE;
368 pnp_register_mem_resource(dev, option_flags, p->minimum, p->maximum,
369 p->alignment, p->address_length, flags);
370 }
371
372 static __init void pnpacpi_parse_mem32_option(struct pnp_dev *dev,
373 unsigned int option_flags,
374 struct acpi_resource_memory32 *p)
375 {
376 unsigned char flags = 0;
377
378 if (p->write_protect == ACPI_READ_WRITE_MEMORY)
379 flags = IORESOURCE_MEM_WRITEABLE;
380 pnp_register_mem_resource(dev, option_flags, p->minimum, p->maximum,
381 p->alignment, p->address_length, flags);
382 }
383
384 static __init void pnpacpi_parse_fixed_mem32_option(struct pnp_dev *dev,
385 unsigned int option_flags,
386 struct acpi_resource_fixed_memory32 *p)
387 {
388 unsigned char flags = 0;
389
390 if (p->write_protect == ACPI_READ_WRITE_MEMORY)
391 flags = IORESOURCE_MEM_WRITEABLE;
392 pnp_register_mem_resource(dev, option_flags, p->address, p->address,
393 0, p->address_length, flags);
394 }
395
396 static __init void pnpacpi_parse_address_option(struct pnp_dev *dev,
397 unsigned int option_flags,
398 struct acpi_resource *r)
399 {
400 struct acpi_resource_address64 addr, *p = &addr;
401 acpi_status status;
402 unsigned char flags = 0;
403
404 status = acpi_resource_to_address64(r, p);
405 if (ACPI_FAILURE(status)) {
406 dev_warn(&dev->dev, "can't convert resource type %d\n",
407 r->type);
408 return;
409 }
410
411 if (p->resource_type == ACPI_MEMORY_RANGE) {
412 if (p->info.mem.write_protect == ACPI_READ_WRITE_MEMORY)
413 flags = IORESOURCE_MEM_WRITEABLE;
414 pnp_register_mem_resource(dev, option_flags, p->address.minimum,
415 p->address.minimum, 0, p->address.address_length,
416 flags);
417 } else if (p->resource_type == ACPI_IO_RANGE)
418 pnp_register_port_resource(dev, option_flags, p->address.minimum,
419 p->address.minimum, 0, p->address.address_length,
420 IORESOURCE_IO_FIXED);
421 }
422
423 static __init void pnpacpi_parse_ext_address_option(struct pnp_dev *dev,
424 unsigned int option_flags,
425 struct acpi_resource *r)
426 {
427 struct acpi_resource_extended_address64 *p = &r->data.ext_address64;
428 unsigned char flags = 0;
429
430 if (p->resource_type == ACPI_MEMORY_RANGE) {
431 if (p->info.mem.write_protect == ACPI_READ_WRITE_MEMORY)
432 flags = IORESOURCE_MEM_WRITEABLE;
433 pnp_register_mem_resource(dev, option_flags, p->address.minimum,
434 p->address.minimum, 0, p->address.address_length,
435 flags);
436 } else if (p->resource_type == ACPI_IO_RANGE)
437 pnp_register_port_resource(dev, option_flags, p->address.minimum,
438 p->address.minimum, 0, p->address.address_length,
439 IORESOURCE_IO_FIXED);
440 }
441
442 struct acpipnp_parse_option_s {
443 struct pnp_dev *dev;
444 unsigned int option_flags;
445 };
446
447 static __init acpi_status pnpacpi_option_resource(struct acpi_resource *res,
448 void *data)
449 {
450 int priority;
451 struct acpipnp_parse_option_s *parse_data = data;
452 struct pnp_dev *dev = parse_data->dev;
453 unsigned int option_flags = parse_data->option_flags;
454
455 switch (res->type) {
456 case ACPI_RESOURCE_TYPE_IRQ:
457 pnpacpi_parse_irq_option(dev, option_flags, &res->data.irq);
458 break;
459
460 case ACPI_RESOURCE_TYPE_DMA:
461 pnpacpi_parse_dma_option(dev, option_flags, &res->data.dma);
462 break;
463
464 case ACPI_RESOURCE_TYPE_START_DEPENDENT:
465 switch (res->data.start_dpf.compatibility_priority) {
466 case ACPI_GOOD_CONFIGURATION:
467 priority = PNP_RES_PRIORITY_PREFERRED;
468 break;
469
470 case ACPI_ACCEPTABLE_CONFIGURATION:
471 priority = PNP_RES_PRIORITY_ACCEPTABLE;
472 break;
473
474 case ACPI_SUB_OPTIMAL_CONFIGURATION:
475 priority = PNP_RES_PRIORITY_FUNCTIONAL;
476 break;
477 default:
478 priority = PNP_RES_PRIORITY_INVALID;
479 break;
480 }
481 parse_data->option_flags = pnp_new_dependent_set(dev, priority);
482 break;
483
484 case ACPI_RESOURCE_TYPE_END_DEPENDENT:
485 parse_data->option_flags = 0;
486 break;
487
488 case ACPI_RESOURCE_TYPE_IO:
489 pnpacpi_parse_port_option(dev, option_flags, &res->data.io);
490 break;
491
492 case ACPI_RESOURCE_TYPE_FIXED_IO:
493 pnpacpi_parse_fixed_port_option(dev, option_flags,
494 &res->data.fixed_io);
495 break;
496
497 case ACPI_RESOURCE_TYPE_VENDOR:
498 case ACPI_RESOURCE_TYPE_END_TAG:
499 break;
500
501 case ACPI_RESOURCE_TYPE_MEMORY24:
502 pnpacpi_parse_mem24_option(dev, option_flags,
503 &res->data.memory24);
504 break;
505
506 case ACPI_RESOURCE_TYPE_MEMORY32:
507 pnpacpi_parse_mem32_option(dev, option_flags,
508 &res->data.memory32);
509 break;
510
511 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
512 pnpacpi_parse_fixed_mem32_option(dev, option_flags,
513 &res->data.fixed_memory32);
514 break;
515
516 case ACPI_RESOURCE_TYPE_ADDRESS16:
517 case ACPI_RESOURCE_TYPE_ADDRESS32:
518 case ACPI_RESOURCE_TYPE_ADDRESS64:
519 pnpacpi_parse_address_option(dev, option_flags, res);
520 break;
521
522 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
523 pnpacpi_parse_ext_address_option(dev, option_flags, res);
524 break;
525
526 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
527 pnpacpi_parse_ext_irq_option(dev, option_flags,
528 &res->data.extended_irq);
529 break;
530
531 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
532 break;
533
534 default:
535 dev_warn(&dev->dev, "unknown resource type %d in _PRS\n",
536 res->type);
537 return AE_ERROR;
538 }
539
540 return AE_OK;
541 }
542
543 int __init pnpacpi_parse_resource_option_data(struct pnp_dev *dev)
544 {
545 struct acpi_device *acpi_dev = dev->data;
546 acpi_handle handle = acpi_dev->handle;
547 acpi_status status;
548 struct acpipnp_parse_option_s parse_data;
549
550 pnp_dbg(&dev->dev, "parse resource options\n");
551
552 parse_data.dev = dev;
553 parse_data.option_flags = 0;
554
555 status = acpi_walk_resources(handle, METHOD_NAME__PRS,
556 pnpacpi_option_resource, &parse_data);
557
558 if (ACPI_FAILURE(status)) {
559 if (status != AE_NOT_FOUND)
560 dev_err(&dev->dev, "can't evaluate _PRS: %d", status);
561 return -EPERM;
562 }
563 return 0;
564 }
565
566 static int pnpacpi_supported_resource(struct acpi_resource *res)
567 {
568 switch (res->type) {
569 case ACPI_RESOURCE_TYPE_IRQ:
570 case ACPI_RESOURCE_TYPE_DMA:
571 case ACPI_RESOURCE_TYPE_IO:
572 case ACPI_RESOURCE_TYPE_FIXED_IO:
573 case ACPI_RESOURCE_TYPE_MEMORY24:
574 case ACPI_RESOURCE_TYPE_MEMORY32:
575 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
576 case ACPI_RESOURCE_TYPE_ADDRESS16:
577 case ACPI_RESOURCE_TYPE_ADDRESS32:
578 case ACPI_RESOURCE_TYPE_ADDRESS64:
579 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
580 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
581 return 1;
582 }
583 return 0;
584 }
585
586 /*
587 * Set resource
588 */
589 static acpi_status pnpacpi_count_resources(struct acpi_resource *res,
590 void *data)
591 {
592 int *res_cnt = data;
593
594 if (pnpacpi_supported_resource(res))
595 (*res_cnt)++;
596 return AE_OK;
597 }
598
599 static acpi_status pnpacpi_type_resources(struct acpi_resource *res, void *data)
600 {
601 struct acpi_resource **resource = data;
602
603 if (pnpacpi_supported_resource(res)) {
604 (*resource)->type = res->type;
605 (*resource)->length = sizeof(struct acpi_resource);
606 if (res->type == ACPI_RESOURCE_TYPE_IRQ)
607 (*resource)->data.irq.descriptor_length =
608 res->data.irq.descriptor_length;
609 (*resource)++;
610 }
611
612 return AE_OK;
613 }
614
615 int pnpacpi_build_resource_template(struct pnp_dev *dev,
616 struct acpi_buffer *buffer)
617 {
618 struct acpi_device *acpi_dev = dev->data;
619 acpi_handle handle = acpi_dev->handle;
620 struct acpi_resource *resource;
621 int res_cnt = 0;
622 acpi_status status;
623
624 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
625 pnpacpi_count_resources, &res_cnt);
626 if (ACPI_FAILURE(status)) {
627 dev_err(&dev->dev, "can't evaluate _CRS: %d\n", status);
628 return -EINVAL;
629 }
630 if (!res_cnt)
631 return -EINVAL;
632 buffer->length = sizeof(struct acpi_resource) * (res_cnt + 1) + 1;
633 buffer->pointer = kzalloc(buffer->length - 1, GFP_KERNEL);
634 if (!buffer->pointer)
635 return -ENOMEM;
636
637 resource = (struct acpi_resource *)buffer->pointer;
638 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
639 pnpacpi_type_resources, &resource);
640 if (ACPI_FAILURE(status)) {
641 kfree(buffer->pointer);
642 dev_err(&dev->dev, "can't evaluate _CRS: %d\n", status);
643 return -EINVAL;
644 }
645 /* resource will pointer the end resource now */
646 resource->type = ACPI_RESOURCE_TYPE_END_TAG;
647 resource->length = sizeof(struct acpi_resource);
648
649 return 0;
650 }
651
652 static void pnpacpi_encode_irq(struct pnp_dev *dev,
653 struct acpi_resource *resource,
654 struct resource *p)
655 {
656 struct acpi_resource_irq *irq = &resource->data.irq;
657 u8 triggering, polarity, shareable;
658
659 if (!pnp_resource_enabled(p)) {
660 irq->interrupt_count = 0;
661 pnp_dbg(&dev->dev, " encode irq (%s)\n",
662 p ? "disabled" : "missing");
663 return;
664 }
665
666 decode_irq_flags(dev, p->flags, &triggering, &polarity, &shareable);
667 irq->triggering = triggering;
668 irq->polarity = polarity;
669 irq->sharable = shareable;
670 irq->interrupt_count = 1;
671 irq->interrupts[0] = p->start;
672
673 pnp_dbg(&dev->dev, " encode irq %d %s %s %s (%d-byte descriptor)\n",
674 (int) p->start,
675 triggering == ACPI_LEVEL_SENSITIVE ? "level" : "edge",
676 polarity == ACPI_ACTIVE_LOW ? "low" : "high",
677 irq->sharable == ACPI_SHARED ? "shared" : "exclusive",
678 irq->descriptor_length);
679 }
680
681 static void pnpacpi_encode_ext_irq(struct pnp_dev *dev,
682 struct acpi_resource *resource,
683 struct resource *p)
684 {
685 struct acpi_resource_extended_irq *extended_irq = &resource->data.extended_irq;
686 u8 triggering, polarity, shareable;
687
688 if (!pnp_resource_enabled(p)) {
689 extended_irq->interrupt_count = 0;
690 pnp_dbg(&dev->dev, " encode extended irq (%s)\n",
691 p ? "disabled" : "missing");
692 return;
693 }
694
695 decode_irq_flags(dev, p->flags, &triggering, &polarity, &shareable);
696 extended_irq->producer_consumer = ACPI_CONSUMER;
697 extended_irq->triggering = triggering;
698 extended_irq->polarity = polarity;
699 extended_irq->sharable = shareable;
700 extended_irq->interrupt_count = 1;
701 extended_irq->interrupts[0] = p->start;
702
703 pnp_dbg(&dev->dev, " encode irq %d %s %s %s\n", (int) p->start,
704 triggering == ACPI_LEVEL_SENSITIVE ? "level" : "edge",
705 polarity == ACPI_ACTIVE_LOW ? "low" : "high",
706 extended_irq->sharable == ACPI_SHARED ? "shared" : "exclusive");
707 }
708
709 static void pnpacpi_encode_dma(struct pnp_dev *dev,
710 struct acpi_resource *resource,
711 struct resource *p)
712 {
713 struct acpi_resource_dma *dma = &resource->data.dma;
714
715 if (!pnp_resource_enabled(p)) {
716 dma->channel_count = 0;
717 pnp_dbg(&dev->dev, " encode dma (%s)\n",
718 p ? "disabled" : "missing");
719 return;
720 }
721
722 /* Note: pnp_assign_dma will copy pnp_dma->flags into p->flags */
723 switch (p->flags & IORESOURCE_DMA_SPEED_MASK) {
724 case IORESOURCE_DMA_TYPEA:
725 dma->type = ACPI_TYPE_A;
726 break;
727 case IORESOURCE_DMA_TYPEB:
728 dma->type = ACPI_TYPE_B;
729 break;
730 case IORESOURCE_DMA_TYPEF:
731 dma->type = ACPI_TYPE_F;
732 break;
733 default:
734 dma->type = ACPI_COMPATIBILITY;
735 }
736
737 switch (p->flags & IORESOURCE_DMA_TYPE_MASK) {
738 case IORESOURCE_DMA_8BIT:
739 dma->transfer = ACPI_TRANSFER_8;
740 break;
741 case IORESOURCE_DMA_8AND16BIT:
742 dma->transfer = ACPI_TRANSFER_8_16;
743 break;
744 default:
745 dma->transfer = ACPI_TRANSFER_16;
746 }
747
748 dma->bus_master = !!(p->flags & IORESOURCE_DMA_MASTER);
749 dma->channel_count = 1;
750 dma->channels[0] = p->start;
751
752 pnp_dbg(&dev->dev, " encode dma %d "
753 "type %#x transfer %#x master %d\n",
754 (int) p->start, dma->type, dma->transfer, dma->bus_master);
755 }
756
757 static void pnpacpi_encode_io(struct pnp_dev *dev,
758 struct acpi_resource *resource,
759 struct resource *p)
760 {
761 struct acpi_resource_io *io = &resource->data.io;
762
763 if (pnp_resource_enabled(p)) {
764 /* Note: pnp_assign_port copies pnp_port->flags into p->flags */
765 io->io_decode = (p->flags & IORESOURCE_IO_16BIT_ADDR) ?
766 ACPI_DECODE_16 : ACPI_DECODE_10;
767 io->minimum = p->start;
768 io->maximum = p->end;
769 io->alignment = 0; /* Correct? */
770 io->address_length = resource_size(p);
771 } else {
772 io->minimum = 0;
773 io->address_length = 0;
774 }
775
776 pnp_dbg(&dev->dev, " encode io %#x-%#x decode %#x\n", io->minimum,
777 io->minimum + io->address_length - 1, io->io_decode);
778 }
779
780 static void pnpacpi_encode_fixed_io(struct pnp_dev *dev,
781 struct acpi_resource *resource,
782 struct resource *p)
783 {
784 struct acpi_resource_fixed_io *fixed_io = &resource->data.fixed_io;
785
786 if (pnp_resource_enabled(p)) {
787 fixed_io->address = p->start;
788 fixed_io->address_length = resource_size(p);
789 } else {
790 fixed_io->address = 0;
791 fixed_io->address_length = 0;
792 }
793
794 pnp_dbg(&dev->dev, " encode fixed_io %#x-%#x\n", fixed_io->address,
795 fixed_io->address + fixed_io->address_length - 1);
796 }
797
798 static void pnpacpi_encode_mem24(struct pnp_dev *dev,
799 struct acpi_resource *resource,
800 struct resource *p)
801 {
802 struct acpi_resource_memory24 *memory24 = &resource->data.memory24;
803
804 if (pnp_resource_enabled(p)) {
805 /* Note: pnp_assign_mem copies pnp_mem->flags into p->flags */
806 memory24->write_protect = p->flags & IORESOURCE_MEM_WRITEABLE ?
807 ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
808 memory24->minimum = p->start;
809 memory24->maximum = p->end;
810 memory24->alignment = 0;
811 memory24->address_length = resource_size(p);
812 } else {
813 memory24->minimum = 0;
814 memory24->address_length = 0;
815 }
816
817 pnp_dbg(&dev->dev, " encode mem24 %#x-%#x write_protect %#x\n",
818 memory24->minimum,
819 memory24->minimum + memory24->address_length - 1,
820 memory24->write_protect);
821 }
822
823 static void pnpacpi_encode_mem32(struct pnp_dev *dev,
824 struct acpi_resource *resource,
825 struct resource *p)
826 {
827 struct acpi_resource_memory32 *memory32 = &resource->data.memory32;
828
829 if (pnp_resource_enabled(p)) {
830 memory32->write_protect = p->flags & IORESOURCE_MEM_WRITEABLE ?
831 ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
832 memory32->minimum = p->start;
833 memory32->maximum = p->end;
834 memory32->alignment = 0;
835 memory32->address_length = resource_size(p);
836 } else {
837 memory32->minimum = 0;
838 memory32->alignment = 0;
839 }
840
841 pnp_dbg(&dev->dev, " encode mem32 %#x-%#x write_protect %#x\n",
842 memory32->minimum,
843 memory32->minimum + memory32->address_length - 1,
844 memory32->write_protect);
845 }
846
847 static void pnpacpi_encode_fixed_mem32(struct pnp_dev *dev,
848 struct acpi_resource *resource,
849 struct resource *p)
850 {
851 struct acpi_resource_fixed_memory32 *fixed_memory32 = &resource->data.fixed_memory32;
852
853 if (pnp_resource_enabled(p)) {
854 fixed_memory32->write_protect =
855 p->flags & IORESOURCE_MEM_WRITEABLE ?
856 ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
857 fixed_memory32->address = p->start;
858 fixed_memory32->address_length = resource_size(p);
859 } else {
860 fixed_memory32->address = 0;
861 fixed_memory32->address_length = 0;
862 }
863
864 pnp_dbg(&dev->dev, " encode fixed_mem32 %#x-%#x write_protect %#x\n",
865 fixed_memory32->address,
866 fixed_memory32->address + fixed_memory32->address_length - 1,
867 fixed_memory32->write_protect);
868 }
869
870 int pnpacpi_encode_resources(struct pnp_dev *dev, struct acpi_buffer *buffer)
871 {
872 int i = 0;
873 /* pnpacpi_build_resource_template allocates extra mem */
874 int res_cnt = (buffer->length - 1) / sizeof(struct acpi_resource) - 1;
875 struct acpi_resource *resource = buffer->pointer;
876 unsigned int port = 0, irq = 0, dma = 0, mem = 0;
877
878 pnp_dbg(&dev->dev, "encode %d resources\n", res_cnt);
879 while (i < res_cnt) {
880 switch (resource->type) {
881 case ACPI_RESOURCE_TYPE_IRQ:
882 pnpacpi_encode_irq(dev, resource,
883 pnp_get_resource(dev, IORESOURCE_IRQ, irq));
884 irq++;
885 break;
886
887 case ACPI_RESOURCE_TYPE_DMA:
888 pnpacpi_encode_dma(dev, resource,
889 pnp_get_resource(dev, IORESOURCE_DMA, dma));
890 dma++;
891 break;
892 case ACPI_RESOURCE_TYPE_IO:
893 pnpacpi_encode_io(dev, resource,
894 pnp_get_resource(dev, IORESOURCE_IO, port));
895 port++;
896 break;
897 case ACPI_RESOURCE_TYPE_FIXED_IO:
898 pnpacpi_encode_fixed_io(dev, resource,
899 pnp_get_resource(dev, IORESOURCE_IO, port));
900 port++;
901 break;
902 case ACPI_RESOURCE_TYPE_MEMORY24:
903 pnpacpi_encode_mem24(dev, resource,
904 pnp_get_resource(dev, IORESOURCE_MEM, mem));
905 mem++;
906 break;
907 case ACPI_RESOURCE_TYPE_MEMORY32:
908 pnpacpi_encode_mem32(dev, resource,
909 pnp_get_resource(dev, IORESOURCE_MEM, mem));
910 mem++;
911 break;
912 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
913 pnpacpi_encode_fixed_mem32(dev, resource,
914 pnp_get_resource(dev, IORESOURCE_MEM, mem));
915 mem++;
916 break;
917 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
918 pnpacpi_encode_ext_irq(dev, resource,
919 pnp_get_resource(dev, IORESOURCE_IRQ, irq));
920 irq++;
921 break;
922 case ACPI_RESOURCE_TYPE_START_DEPENDENT:
923 case ACPI_RESOURCE_TYPE_END_DEPENDENT:
924 case ACPI_RESOURCE_TYPE_VENDOR:
925 case ACPI_RESOURCE_TYPE_END_TAG:
926 case ACPI_RESOURCE_TYPE_ADDRESS16:
927 case ACPI_RESOURCE_TYPE_ADDRESS32:
928 case ACPI_RESOURCE_TYPE_ADDRESS64:
929 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
930 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
931 default: /* other type */
932 dev_warn(&dev->dev, "can't encode unknown resource "
933 "type %d\n", resource->type);
934 return -EINVAL;
935 }
936 resource++;
937 i++;
938 }
939 return 0;
940 }
Linux with added FPC-III support