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