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 case ACPI_RESOURCE_TYPE_SERIAL_BUS:
256
257 break;
258
259 default:
260 dev_warn(&dev->dev, "unknown resource type %d in _CRS\n",
261 res->type);
262 return AE_ERROR;
263 }
264
265 return AE_OK;
266}
267
268int pnpacpi_parse_allocated_resource(struct pnp_dev *dev)
269{
270 struct acpi_device *acpi_dev = dev->data;
271 acpi_handle handle = acpi_dev->handle;
272 acpi_status status;
273
274 pnp_dbg(&dev->dev, "parse allocated resources\n");
275
276 pnp_init_resources(dev);
277
278 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
279 pnpacpi_allocated_resource, dev);
280
281 if (ACPI_FAILURE(status)) {
282 if (status != AE_NOT_FOUND)
283 dev_err(&dev->dev, "can't evaluate _CRS: %d", status);
284 return -EPERM;
285 }
286 return 0;
287}
288
289static __init void pnpacpi_parse_dma_option(struct pnp_dev *dev,
290 unsigned int option_flags,
291 struct acpi_resource_dma *p)
292{
293 int i;
294 unsigned char map = 0, flags;
295
296 for (i = 0; i < p->channel_count; i++)
297 map |= 1 << p->channels[i];
298
299 flags = dma_flags(dev, p->type, p->bus_master, p->transfer);
300 pnp_register_dma_resource(dev, option_flags, map, flags);
301}
302
303static __init void pnpacpi_parse_irq_option(struct pnp_dev *dev,
304 unsigned int option_flags,
305 struct acpi_resource_irq *p)
306{
307 int i;
308 pnp_irq_mask_t map;
309 unsigned char flags;
310
311 bitmap_zero(map.bits, PNP_IRQ_NR);
312 for (i = 0; i < p->interrupt_count; i++)
313 if (p->interrupts[i])
314 __set_bit(p->interrupts[i], map.bits);
315
316 flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->sharable);
317 pnp_register_irq_resource(dev, option_flags, &map, flags);
318}
319
320static __init void pnpacpi_parse_ext_irq_option(struct pnp_dev *dev,
321 unsigned int option_flags,
322 struct acpi_resource_extended_irq *p)
323{
324 int i;
325 pnp_irq_mask_t map;
326 unsigned char flags;
327
328 bitmap_zero(map.bits, PNP_IRQ_NR);
329 for (i = 0; i < p->interrupt_count; i++) {
330 if (p->interrupts[i]) {
331 if (p->interrupts[i] < PNP_IRQ_NR)
332 __set_bit(p->interrupts[i], map.bits);
333 else
334 dev_err(&dev->dev, "ignoring IRQ %d option "
335 "(too large for %d entry bitmap)\n",
336 p->interrupts[i], PNP_IRQ_NR);
337 }
338 }
339
340 flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->sharable);
341 pnp_register_irq_resource(dev, option_flags, &map, flags);
342}
343
344static __init void pnpacpi_parse_port_option(struct pnp_dev *dev,
345 unsigned int option_flags,
346 struct acpi_resource_io *io)
347{
348 unsigned char flags = 0;
349
350 if (io->io_decode == ACPI_DECODE_16)
351 flags = IORESOURCE_IO_16BIT_ADDR;
352 pnp_register_port_resource(dev, option_flags, io->minimum, io->maximum,
353 io->alignment, io->address_length, flags);
354}
355
356static __init void pnpacpi_parse_fixed_port_option(struct pnp_dev *dev,
357 unsigned int option_flags,
358 struct acpi_resource_fixed_io *io)
359{
360 pnp_register_port_resource(dev, option_flags, io->address, io->address,
361 0, io->address_length, IORESOURCE_IO_FIXED);
362}
363
364static __init void pnpacpi_parse_mem24_option(struct pnp_dev *dev,
365 unsigned int option_flags,
366 struct acpi_resource_memory24 *p)
367{
368 unsigned char flags = 0;
369
370 if (p->write_protect == ACPI_READ_WRITE_MEMORY)
371 flags = IORESOURCE_MEM_WRITEABLE;
372 pnp_register_mem_resource(dev, option_flags, p->minimum, p->maximum,
373 p->alignment, p->address_length, flags);
374}
375
376static __init void pnpacpi_parse_mem32_option(struct pnp_dev *dev,
377 unsigned int option_flags,
378 struct acpi_resource_memory32 *p)
379{
380 unsigned char flags = 0;
381
382 if (p->write_protect == ACPI_READ_WRITE_MEMORY)
383 flags = IORESOURCE_MEM_WRITEABLE;
384 pnp_register_mem_resource(dev, option_flags, p->minimum, p->maximum,
385 p->alignment, p->address_length, flags);
386}
387
388static __init void pnpacpi_parse_fixed_mem32_option(struct pnp_dev *dev,
389 unsigned int option_flags,
390 struct acpi_resource_fixed_memory32 *p)
391{
392 unsigned char flags = 0;
393
394 if (p->write_protect == ACPI_READ_WRITE_MEMORY)
395 flags = IORESOURCE_MEM_WRITEABLE;
396 pnp_register_mem_resource(dev, option_flags, p->address, p->address,
397 0, p->address_length, flags);
398}
399
400static __init void pnpacpi_parse_address_option(struct pnp_dev *dev,
401 unsigned int option_flags,
402 struct acpi_resource *r)
403{
404 struct acpi_resource_address64 addr, *p = &addr;
405 acpi_status status;
406 unsigned char flags = 0;
407
408 status = acpi_resource_to_address64(r, p);
409 if (ACPI_FAILURE(status)) {
410 dev_warn(&dev->dev, "can't convert resource type %d\n",
411 r->type);
412 return;
413 }
414
415 if (p->resource_type == ACPI_MEMORY_RANGE) {
416 if (p->info.mem.write_protect == ACPI_READ_WRITE_MEMORY)
417 flags = IORESOURCE_MEM_WRITEABLE;
418 pnp_register_mem_resource(dev, option_flags, p->address.minimum,
419 p->address.minimum, 0, p->address.address_length,
420 flags);
421 } else if (p->resource_type == ACPI_IO_RANGE)
422 pnp_register_port_resource(dev, option_flags, p->address.minimum,
423 p->address.minimum, 0, p->address.address_length,
424 IORESOURCE_IO_FIXED);
425}
426
427static __init void pnpacpi_parse_ext_address_option(struct pnp_dev *dev,
428 unsigned int option_flags,
429 struct acpi_resource *r)
430{
431 struct acpi_resource_extended_address64 *p = &r->data.ext_address64;
432 unsigned char flags = 0;
433
434 if (p->resource_type == ACPI_MEMORY_RANGE) {
435 if (p->info.mem.write_protect == ACPI_READ_WRITE_MEMORY)
436 flags = IORESOURCE_MEM_WRITEABLE;
437 pnp_register_mem_resource(dev, option_flags, p->address.minimum,
438 p->address.minimum, 0, p->address.address_length,
439 flags);
440 } else if (p->resource_type == ACPI_IO_RANGE)
441 pnp_register_port_resource(dev, option_flags, p->address.minimum,
442 p->address.minimum, 0, p->address.address_length,
443 IORESOURCE_IO_FIXED);
444}
445
446struct acpipnp_parse_option_s {
447 struct pnp_dev *dev;
448 unsigned int option_flags;
449};
450
451static __init acpi_status pnpacpi_option_resource(struct acpi_resource *res,
452 void *data)
453{
454 int priority;
455 struct acpipnp_parse_option_s *parse_data = data;
456 struct pnp_dev *dev = parse_data->dev;
457 unsigned int option_flags = parse_data->option_flags;
458
459 switch (res->type) {
460 case ACPI_RESOURCE_TYPE_IRQ:
461 pnpacpi_parse_irq_option(dev, option_flags, &res->data.irq);
462 break;
463
464 case ACPI_RESOURCE_TYPE_DMA:
465 pnpacpi_parse_dma_option(dev, option_flags, &res->data.dma);
466 break;
467
468 case ACPI_RESOURCE_TYPE_START_DEPENDENT:
469 switch (res->data.start_dpf.compatibility_priority) {
470 case ACPI_GOOD_CONFIGURATION:
471 priority = PNP_RES_PRIORITY_PREFERRED;
472 break;
473
474 case ACPI_ACCEPTABLE_CONFIGURATION:
475 priority = PNP_RES_PRIORITY_ACCEPTABLE;
476 break;
477
478 case ACPI_SUB_OPTIMAL_CONFIGURATION:
479 priority = PNP_RES_PRIORITY_FUNCTIONAL;
480 break;
481 default:
482 priority = PNP_RES_PRIORITY_INVALID;
483 break;
484 }
485 parse_data->option_flags = pnp_new_dependent_set(dev, priority);
486 break;
487
488 case ACPI_RESOURCE_TYPE_END_DEPENDENT:
489 parse_data->option_flags = 0;
490 break;
491
492 case ACPI_RESOURCE_TYPE_IO:
493 pnpacpi_parse_port_option(dev, option_flags, &res->data.io);
494 break;
495
496 case ACPI_RESOURCE_TYPE_FIXED_IO:
497 pnpacpi_parse_fixed_port_option(dev, option_flags,
498 &res->data.fixed_io);
499 break;
500
501 case ACPI_RESOURCE_TYPE_VENDOR:
502 case ACPI_RESOURCE_TYPE_END_TAG:
503 break;
504
505 case ACPI_RESOURCE_TYPE_MEMORY24:
506 pnpacpi_parse_mem24_option(dev, option_flags,
507 &res->data.memory24);
508 break;
509
510 case ACPI_RESOURCE_TYPE_MEMORY32:
511 pnpacpi_parse_mem32_option(dev, option_flags,
512 &res->data.memory32);
513 break;
514
515 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
516 pnpacpi_parse_fixed_mem32_option(dev, option_flags,
517 &res->data.fixed_memory32);
518 break;
519
520 case ACPI_RESOURCE_TYPE_ADDRESS16:
521 case ACPI_RESOURCE_TYPE_ADDRESS32:
522 case ACPI_RESOURCE_TYPE_ADDRESS64:
523 pnpacpi_parse_address_option(dev, option_flags, res);
524 break;
525
526 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
527 pnpacpi_parse_ext_address_option(dev, option_flags, res);
528 break;
529
530 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
531 pnpacpi_parse_ext_irq_option(dev, option_flags,
532 &res->data.extended_irq);
533 break;
534
535 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
536 break;
537
538 default:
539 dev_warn(&dev->dev, "unknown resource type %d in _PRS\n",
540 res->type);
541 return AE_ERROR;
542 }
543
544 return AE_OK;
545}
546
547int __init pnpacpi_parse_resource_option_data(struct pnp_dev *dev)
548{
549 struct acpi_device *acpi_dev = dev->data;
550 acpi_handle handle = acpi_dev->handle;
551 acpi_status status;
552 struct acpipnp_parse_option_s parse_data;
553
554 pnp_dbg(&dev->dev, "parse resource options\n");
555
556 parse_data.dev = dev;
557 parse_data.option_flags = 0;
558
559 status = acpi_walk_resources(handle, METHOD_NAME__PRS,
560 pnpacpi_option_resource, &parse_data);
561
562 if (ACPI_FAILURE(status)) {
563 if (status != AE_NOT_FOUND)
564 dev_err(&dev->dev, "can't evaluate _PRS: %d", status);
565 return -EPERM;
566 }
567 return 0;
568}
569
570static int pnpacpi_supported_resource(struct acpi_resource *res)
571{
572 switch (res->type) {
573 case ACPI_RESOURCE_TYPE_IRQ:
574 case ACPI_RESOURCE_TYPE_DMA:
575 case ACPI_RESOURCE_TYPE_IO:
576 case ACPI_RESOURCE_TYPE_FIXED_IO:
577 case ACPI_RESOURCE_TYPE_MEMORY24:
578 case ACPI_RESOURCE_TYPE_MEMORY32:
579 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
580 case ACPI_RESOURCE_TYPE_ADDRESS16:
581 case ACPI_RESOURCE_TYPE_ADDRESS32:
582 case ACPI_RESOURCE_TYPE_ADDRESS64:
583 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
584 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
585 return 1;
586 }
587 return 0;
588}
589
590
591
592
593static acpi_status pnpacpi_count_resources(struct acpi_resource *res,
594 void *data)
595{
596 int *res_cnt = data;
597
598 if (pnpacpi_supported_resource(res))
599 (*res_cnt)++;
600 return AE_OK;
601}
602
603static acpi_status pnpacpi_type_resources(struct acpi_resource *res, void *data)
604{
605 struct acpi_resource **resource = data;
606
607 if (pnpacpi_supported_resource(res)) {
608 (*resource)->type = res->type;
609 (*resource)->length = sizeof(struct acpi_resource);
610 if (res->type == ACPI_RESOURCE_TYPE_IRQ)
611 (*resource)->data.irq.descriptor_length =
612 res->data.irq.descriptor_length;
613 (*resource)++;
614 }
615
616 return AE_OK;
617}
618
619int pnpacpi_build_resource_template(struct pnp_dev *dev,
620 struct acpi_buffer *buffer)
621{
622 struct acpi_device *acpi_dev = dev->data;
623 acpi_handle handle = acpi_dev->handle;
624 struct acpi_resource *resource;
625 int res_cnt = 0;
626 acpi_status status;
627
628 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
629 pnpacpi_count_resources, &res_cnt);
630 if (ACPI_FAILURE(status)) {
631 dev_err(&dev->dev, "can't evaluate _CRS: %d\n", status);
632 return -EINVAL;
633 }
634 if (!res_cnt)
635 return -EINVAL;
636 buffer->length = sizeof(struct acpi_resource) * (res_cnt + 1) + 1;
637 buffer->pointer = kzalloc(buffer->length - 1, GFP_KERNEL);
638 if (!buffer->pointer)
639 return -ENOMEM;
640
641 resource = (struct acpi_resource *)buffer->pointer;
642 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
643 pnpacpi_type_resources, &resource);
644 if (ACPI_FAILURE(status)) {
645 kfree(buffer->pointer);
646 dev_err(&dev->dev, "can't evaluate _CRS: %d\n", status);
647 return -EINVAL;
648 }
649
650 resource->type = ACPI_RESOURCE_TYPE_END_TAG;
651 resource->length = sizeof(struct acpi_resource);
652
653 return 0;
654}
655
656static void pnpacpi_encode_irq(struct pnp_dev *dev,
657 struct acpi_resource *resource,
658 struct resource *p)
659{
660 struct acpi_resource_irq *irq = &resource->data.irq;
661 u8 triggering, polarity, shareable;
662
663 if (!pnp_resource_enabled(p)) {
664 irq->interrupt_count = 0;
665 pnp_dbg(&dev->dev, " encode irq (%s)\n",
666 p ? "disabled" : "missing");
667 return;
668 }
669
670 decode_irq_flags(dev, p->flags, &triggering, &polarity, &shareable);
671 irq->triggering = triggering;
672 irq->polarity = polarity;
673 irq->sharable = shareable;
674 irq->interrupt_count = 1;
675 irq->interrupts[0] = p->start;
676
677 pnp_dbg(&dev->dev, " encode irq %d %s %s %s (%d-byte descriptor)\n",
678 (int) p->start,
679 triggering == ACPI_LEVEL_SENSITIVE ? "level" : "edge",
680 polarity == ACPI_ACTIVE_LOW ? "low" : "high",
681 irq->sharable == ACPI_SHARED ? "shared" : "exclusive",
682 irq->descriptor_length);
683}
684
685static void pnpacpi_encode_ext_irq(struct pnp_dev *dev,
686 struct acpi_resource *resource,
687 struct resource *p)
688{
689 struct acpi_resource_extended_irq *extended_irq = &resource->data.extended_irq;
690 u8 triggering, polarity, shareable;
691
692 if (!pnp_resource_enabled(p)) {
693 extended_irq->interrupt_count = 0;
694 pnp_dbg(&dev->dev, " encode extended irq (%s)\n",
695 p ? "disabled" : "missing");
696 return;
697 }
698
699 decode_irq_flags(dev, p->flags, &triggering, &polarity, &shareable);
700 extended_irq->producer_consumer = ACPI_CONSUMER;
701 extended_irq->triggering = triggering;
702 extended_irq->polarity = polarity;
703 extended_irq->sharable = shareable;
704 extended_irq->interrupt_count = 1;
705 extended_irq->interrupts[0] = p->start;
706
707 pnp_dbg(&dev->dev, " encode irq %d %s %s %s\n", (int) p->start,
708 triggering == ACPI_LEVEL_SENSITIVE ? "level" : "edge",
709 polarity == ACPI_ACTIVE_LOW ? "low" : "high",
710 extended_irq->sharable == ACPI_SHARED ? "shared" : "exclusive");
711}
712
713static void pnpacpi_encode_dma(struct pnp_dev *dev,
714 struct acpi_resource *resource,
715 struct resource *p)
716{
717 struct acpi_resource_dma *dma = &resource->data.dma;
718
719 if (!pnp_resource_enabled(p)) {
720 dma->channel_count = 0;
721 pnp_dbg(&dev->dev, " encode dma (%s)\n",
722 p ? "disabled" : "missing");
723 return;
724 }
725
726
727 switch (p->flags & IORESOURCE_DMA_SPEED_MASK) {
728 case IORESOURCE_DMA_TYPEA:
729 dma->type = ACPI_TYPE_A;
730 break;
731 case IORESOURCE_DMA_TYPEB:
732 dma->type = ACPI_TYPE_B;
733 break;
734 case IORESOURCE_DMA_TYPEF:
735 dma->type = ACPI_TYPE_F;
736 break;
737 default:
738 dma->type = ACPI_COMPATIBILITY;
739 }
740
741 switch (p->flags & IORESOURCE_DMA_TYPE_MASK) {
742 case IORESOURCE_DMA_8BIT:
743 dma->transfer = ACPI_TRANSFER_8;
744 break;
745 case IORESOURCE_DMA_8AND16BIT:
746 dma->transfer = ACPI_TRANSFER_8_16;
747 break;
748 default:
749 dma->transfer = ACPI_TRANSFER_16;
750 }
751
752 dma->bus_master = !!(p->flags & IORESOURCE_DMA_MASTER);
753 dma->channel_count = 1;
754 dma->channels[0] = p->start;
755
756 pnp_dbg(&dev->dev, " encode dma %d "
757 "type %#x transfer %#x master %d\n",
758 (int) p->start, dma->type, dma->transfer, dma->bus_master);
759}
760
761static void pnpacpi_encode_io(struct pnp_dev *dev,
762 struct acpi_resource *resource,
763 struct resource *p)
764{
765 struct acpi_resource_io *io = &resource->data.io;
766
767 if (pnp_resource_enabled(p)) {
768
769 io->io_decode = (p->flags & IORESOURCE_IO_16BIT_ADDR) ?
770 ACPI_DECODE_16 : ACPI_DECODE_10;
771 io->minimum = p->start;
772 io->maximum = p->end;
773 io->alignment = 0;
774 io->address_length = resource_size(p);
775 } else {
776 io->minimum = 0;
777 io->address_length = 0;
778 }
779
780 pnp_dbg(&dev->dev, " encode io %#x-%#x decode %#x\n", io->minimum,
781 io->minimum + io->address_length - 1, io->io_decode);
782}
783
784static void pnpacpi_encode_fixed_io(struct pnp_dev *dev,
785 struct acpi_resource *resource,
786 struct resource *p)
787{
788 struct acpi_resource_fixed_io *fixed_io = &resource->data.fixed_io;
789
790 if (pnp_resource_enabled(p)) {
791 fixed_io->address = p->start;
792 fixed_io->address_length = resource_size(p);
793 } else {
794 fixed_io->address = 0;
795 fixed_io->address_length = 0;
796 }
797
798 pnp_dbg(&dev->dev, " encode fixed_io %#x-%#x\n", fixed_io->address,
799 fixed_io->address + fixed_io->address_length - 1);
800}
801
802static void pnpacpi_encode_mem24(struct pnp_dev *dev,
803 struct acpi_resource *resource,
804 struct resource *p)
805{
806 struct acpi_resource_memory24 *memory24 = &resource->data.memory24;
807
808 if (pnp_resource_enabled(p)) {
809
810 memory24->write_protect = p->flags & IORESOURCE_MEM_WRITEABLE ?
811 ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
812 memory24->minimum = p->start;
813 memory24->maximum = p->end;
814 memory24->alignment = 0;
815 memory24->address_length = resource_size(p);
816 } else {
817 memory24->minimum = 0;
818 memory24->address_length = 0;
819 }
820
821 pnp_dbg(&dev->dev, " encode mem24 %#x-%#x write_protect %#x\n",
822 memory24->minimum,
823 memory24->minimum + memory24->address_length - 1,
824 memory24->write_protect);
825}
826
827static void pnpacpi_encode_mem32(struct pnp_dev *dev,
828 struct acpi_resource *resource,
829 struct resource *p)
830{
831 struct acpi_resource_memory32 *memory32 = &resource->data.memory32;
832
833 if (pnp_resource_enabled(p)) {
834 memory32->write_protect = p->flags & IORESOURCE_MEM_WRITEABLE ?
835 ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
836 memory32->minimum = p->start;
837 memory32->maximum = p->end;
838 memory32->alignment = 0;
839 memory32->address_length = resource_size(p);
840 } else {
841 memory32->minimum = 0;
842 memory32->alignment = 0;
843 }
844
845 pnp_dbg(&dev->dev, " encode mem32 %#x-%#x write_protect %#x\n",
846 memory32->minimum,
847 memory32->minimum + memory32->address_length - 1,
848 memory32->write_protect);
849}
850
851static void pnpacpi_encode_fixed_mem32(struct pnp_dev *dev,
852 struct acpi_resource *resource,
853 struct resource *p)
854{
855 struct acpi_resource_fixed_memory32 *fixed_memory32 = &resource->data.fixed_memory32;
856
857 if (pnp_resource_enabled(p)) {
858 fixed_memory32->write_protect =
859 p->flags & IORESOURCE_MEM_WRITEABLE ?
860 ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
861 fixed_memory32->address = p->start;
862 fixed_memory32->address_length = resource_size(p);
863 } else {
864 fixed_memory32->address = 0;
865 fixed_memory32->address_length = 0;
866 }
867
868 pnp_dbg(&dev->dev, " encode fixed_mem32 %#x-%#x write_protect %#x\n",
869 fixed_memory32->address,
870 fixed_memory32->address + fixed_memory32->address_length - 1,
871 fixed_memory32->write_protect);
872}
873
874int pnpacpi_encode_resources(struct pnp_dev *dev, struct acpi_buffer *buffer)
875{
876 int i = 0;
877
878 int res_cnt = (buffer->length - 1) / sizeof(struct acpi_resource) - 1;
879 struct acpi_resource *resource = buffer->pointer;
880 unsigned int port = 0, irq = 0, dma = 0, mem = 0;
881
882 pnp_dbg(&dev->dev, "encode %d resources\n", res_cnt);
883 while (i < res_cnt) {
884 switch (resource->type) {
885 case ACPI_RESOURCE_TYPE_IRQ:
886 pnpacpi_encode_irq(dev, resource,
887 pnp_get_resource(dev, IORESOURCE_IRQ, irq));
888 irq++;
889 break;
890
891 case ACPI_RESOURCE_TYPE_DMA:
892 pnpacpi_encode_dma(dev, resource,
893 pnp_get_resource(dev, IORESOURCE_DMA, dma));
894 dma++;
895 break;
896 case ACPI_RESOURCE_TYPE_IO:
897 pnpacpi_encode_io(dev, resource,
898 pnp_get_resource(dev, IORESOURCE_IO, port));
899 port++;
900 break;
901 case ACPI_RESOURCE_TYPE_FIXED_IO:
902 pnpacpi_encode_fixed_io(dev, resource,
903 pnp_get_resource(dev, IORESOURCE_IO, port));
904 port++;
905 break;
906 case ACPI_RESOURCE_TYPE_MEMORY24:
907 pnpacpi_encode_mem24(dev, resource,
908 pnp_get_resource(dev, IORESOURCE_MEM, mem));
909 mem++;
910 break;
911 case ACPI_RESOURCE_TYPE_MEMORY32:
912 pnpacpi_encode_mem32(dev, resource,
913 pnp_get_resource(dev, IORESOURCE_MEM, mem));
914 mem++;
915 break;
916 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
917 pnpacpi_encode_fixed_mem32(dev, resource,
918 pnp_get_resource(dev, IORESOURCE_MEM, mem));
919 mem++;
920 break;
921 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
922 pnpacpi_encode_ext_irq(dev, resource,
923 pnp_get_resource(dev, IORESOURCE_IRQ, irq));
924 irq++;
925 break;
926 case ACPI_RESOURCE_TYPE_START_DEPENDENT:
927 case ACPI_RESOURCE_TYPE_END_DEPENDENT:
928 case ACPI_RESOURCE_TYPE_VENDOR:
929 case ACPI_RESOURCE_TYPE_END_TAG:
930 case ACPI_RESOURCE_TYPE_ADDRESS16:
931 case ACPI_RESOURCE_TYPE_ADDRESS32:
932 case ACPI_RESOURCE_TYPE_ADDRESS64:
933 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
934 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
935 default:
936 dev_warn(&dev->dev, "can't encode unknown resource "
937 "type %d\n", resource->type);
938 return -EINVAL;
939 }
940 resource++;
941 i++;
942 }
943 return 0;
944}
945
