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