1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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
31static 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
66static 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
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
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
112
113
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);
118
119 pnp_add_resource(dev, r);
120}
121
122
123
124
125
126
127
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
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
177static 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
202
203
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
264int 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
285static __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
299static __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
316static __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
340static __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
352static __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
360static __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
372static __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
384static __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
396static __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
423static __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
442struct acpipnp_parse_option_s {
443 struct pnp_dev *dev;
444 unsigned int option_flags;
445};
446
447static __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
543int __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
566static 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
588
589static 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
599static 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
615int 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
646 resource->type = ACPI_RESOURCE_TYPE_END_TAG;
647 resource->length = sizeof(struct acpi_resource);
648
649 return 0;
650}
651
652static 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
681static 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
709static 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
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
757static 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
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;
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
780static 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
798static 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
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
823static 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
847static 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
870int pnpacpi_encode_resources(struct pnp_dev *dev, struct acpi_buffer *buffer)
871{
872 int i = 0;
873
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:
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}
941
