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