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
decode_irq_flags(struct pnp_dev * dev,int flags,u8 * triggering,u8 * polarity,u8 * shareable)18 static void decode_irq_flags(struct pnp_dev *dev, int flags, u8 *triggering,
19 u8 *polarity, u8 *shareable)
20 {
21 switch (flags & (IORESOURCE_IRQ_LOWLEVEL | IORESOURCE_IRQ_HIGHLEVEL |
22 IORESOURCE_IRQ_LOWEDGE | IORESOURCE_IRQ_HIGHEDGE)) {
23 case IORESOURCE_IRQ_LOWLEVEL:
24 *triggering = ACPI_LEVEL_SENSITIVE;
25 *polarity = ACPI_ACTIVE_LOW;
26 break;
27 case IORESOURCE_IRQ_HIGHLEVEL:
28 *triggering = ACPI_LEVEL_SENSITIVE;
29 *polarity = ACPI_ACTIVE_HIGH;
30 break;
31 case IORESOURCE_IRQ_LOWEDGE:
32 *triggering = ACPI_EDGE_SENSITIVE;
33 *polarity = ACPI_ACTIVE_LOW;
34 break;
35 case IORESOURCE_IRQ_HIGHEDGE:
36 *triggering = ACPI_EDGE_SENSITIVE;
37 *polarity = ACPI_ACTIVE_HIGH;
38 break;
39 default:
40 dev_err(&dev->dev, "can't encode invalid IRQ mode %#x\n",
41 flags);
42 *triggering = ACPI_EDGE_SENSITIVE;
43 *polarity = ACPI_ACTIVE_HIGH;
44 break;
45 }
46
47 if (flags & IORESOURCE_IRQ_SHAREABLE)
48 *shareable = ACPI_SHARED;
49 else
50 *shareable = ACPI_EXCLUSIVE;
51 }
52
dma_flags(struct pnp_dev * dev,int type,int bus_master,int transfer)53 static int dma_flags(struct pnp_dev *dev, int type, int bus_master,
54 int transfer)
55 {
56 int flags = 0;
57
58 if (bus_master)
59 flags |= IORESOURCE_DMA_MASTER;
60 switch (type) {
61 case ACPI_COMPATIBILITY:
62 flags |= IORESOURCE_DMA_COMPATIBLE;
63 break;
64 case ACPI_TYPE_A:
65 flags |= IORESOURCE_DMA_TYPEA;
66 break;
67 case ACPI_TYPE_B:
68 flags |= IORESOURCE_DMA_TYPEB;
69 break;
70 case ACPI_TYPE_F:
71 flags |= IORESOURCE_DMA_TYPEF;
72 break;
73 default:
74 /* 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
pnpacpi_add_irqresource(struct pnp_dev * dev,struct resource * r)101 static void pnpacpi_add_irqresource(struct pnp_dev *dev, struct resource *r)
102 {
103 if (!(r->flags & IORESOURCE_DISABLED))
104 pcibios_penalize_isa_irq(r->start, 1);
105
106 pnp_add_resource(dev, r);
107 }
108
109 /*
110 * 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 */
116 static struct acpi_vendor_uuid hp_ccsr_uuid = {
117 .subtype = 2,
118 .data = { 0xf9, 0xad, 0xe9, 0x69, 0x4f, 0x92, 0x5f, 0xab, 0xf6, 0x4a,
119 0x24, 0xd2, 0x01, 0x37, 0x0e, 0xad },
120 };
121
vendor_resource_matches(struct pnp_dev * dev,struct acpi_resource_vendor_typed * vendor,struct acpi_vendor_uuid * match,int expected_len)122 static int vendor_resource_matches(struct pnp_dev *dev,
123 struct acpi_resource_vendor_typed *vendor,
124 struct acpi_vendor_uuid *match,
125 int expected_len)
126 {
127 int uuid_len = sizeof(vendor->uuid);
128 u8 uuid_subtype = vendor->uuid_subtype;
129 u8 *uuid = vendor->uuid;
130 int actual_len;
131
132 /* 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
pnpacpi_parse_allocated_vendor(struct pnp_dev * dev,struct acpi_resource_vendor_typed * vendor)151 static 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, &hp_ccsr_uuid,
157 sizeof(range))) {
158 memcpy(&range, vendor->byte_data, sizeof(range));
159 pnp_add_mem_resource(dev, range.start, range.start +
160 range.length - 1, 0);
161 }
162 }
163
pnpacpi_allocated_resource(struct acpi_resource * res,void * data)164 static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res,
165 void *data)
166 {
167 struct pnp_dev *dev = data;
168 struct acpi_resource_dma *dma;
169 struct acpi_resource_vendor_typed *vendor_typed;
170 struct acpi_resource_gpio *gpio;
171 struct resource_win win = {{0}, 0};
172 struct resource *r = &win.res;
173 int i, flags;
174
175 if (acpi_dev_resource_address_space(res, &win)
176 || acpi_dev_resource_ext_address_space(res, &win)) {
177 pnp_add_resource(dev, &win.res);
178 return AE_OK;
179 }
180
181 r->flags = 0;
182 if (acpi_dev_resource_interrupt(res, 0, r)) {
183 pnpacpi_add_irqresource(dev, r);
184 for (i = 1; acpi_dev_resource_interrupt(res, i, r); i++)
185 pnpacpi_add_irqresource(dev, r);
186
187 if (i > 1) {
188 /*
189 * 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(res, &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(dev->data, 0);
206 if (i >= 0) {
207 flags = acpi_dev_irq_flags(gpio->triggering,
208 gpio->polarity,
209 gpio->shareable,
210 gpio->wake_capable);
211 } else {
212 flags = IORESOURCE_DISABLED;
213 }
214 pnp_add_irq_resource(dev, i, flags);
215 return AE_OK;
216 } else if (r->flags & IORESOURCE_DISABLED) {
217 pnp_add_irq_resource(dev, 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(res, r))
226 pnp_add_resource(dev, r);
227 break;
228 case ACPI_RESOURCE_TYPE_IO:
229 case ACPI_RESOURCE_TYPE_FIXED_IO:
230 if (acpi_dev_resource_io(res, r))
231 pnp_add_resource(dev, 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, dma->type, dma->bus_master,
237 dma->transfer);
238 else
239 flags = IORESOURCE_DISABLED;
240 pnp_add_dma_resource(dev, 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_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
pnpacpi_parse_allocated_resource(struct pnp_dev * dev)271 int 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(handle, METHOD_NAME__CRS,
282 pnpacpi_allocated_resource, 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
pnpacpi_parse_dma_option(struct pnp_dev * dev,unsigned int option_flags,struct acpi_resource_dma * p)292 static __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, p->type, p->bus_master, p->transfer);
303 pnp_register_dma_resource(dev, option_flags, map, flags);
304 }
305
pnpacpi_parse_irq_option(struct pnp_dev * dev,unsigned int option_flags,struct acpi_resource_irq * p)306 static __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(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(p->triggering, p->polarity, p->shareable, p->wake_capable);
320 pnp_register_irq_resource(dev, option_flags, &map, flags);
321 }
322
pnpacpi_parse_ext_irq_option(struct pnp_dev * dev,unsigned int option_flags,struct acpi_resource_extended_irq * p)323 static __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(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(p->triggering, p->polarity, p->shareable, p->wake_capable);
344 pnp_register_irq_resource(dev, option_flags, &map, flags);
345 }
346
pnpacpi_parse_port_option(struct pnp_dev * dev,unsigned int option_flags,struct acpi_resource_io * io)347 static __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, io->minimum, io->maximum,
356 io->alignment, io->address_length, flags);
357 }
358
pnpacpi_parse_fixed_port_option(struct pnp_dev * dev,unsigned int option_flags,struct acpi_resource_fixed_io * io)359 static __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, io->address, io->address,
364 0, io->address_length, IORESOURCE_IO_FIXED);
365 }
366
pnpacpi_parse_mem24_option(struct pnp_dev * dev,unsigned int option_flags,struct acpi_resource_memory24 * p)367 static __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, p->minimum, p->maximum,
376 p->alignment, p->address_length, flags);
377 }
378
pnpacpi_parse_mem32_option(struct pnp_dev * dev,unsigned int option_flags,struct acpi_resource_memory32 * p)379 static __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, p->minimum, p->maximum,
388 p->alignment, p->address_length, flags);
389 }
390
pnpacpi_parse_fixed_mem32_option(struct pnp_dev * dev,unsigned int option_flags,struct acpi_resource_fixed_memory32 * p)391 static __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, p->address, p->address,
400 0, p->address_length, flags);
401 }
402
pnpacpi_parse_address_option(struct pnp_dev * dev,unsigned int option_flags,struct acpi_resource * r)403 static __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(r, 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, p->address.minimum,
422 p->address.minimum, 0, p->address.address_length,
423 flags);
424 } else if (p->resource_type == ACPI_IO_RANGE)
425 pnp_register_port_resource(dev, option_flags, p->address.minimum,
426 p->address.minimum, 0, p->address.address_length,
427 IORESOURCE_IO_FIXED);
428 }
429
pnpacpi_parse_ext_address_option(struct pnp_dev * dev,unsigned int option_flags,struct acpi_resource * r)430 static __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, p->address.minimum,
441 p->address.minimum, 0, p->address.address_length,
442 flags);
443 } else if (p->resource_type == ACPI_IO_RANGE)
444 pnp_register_port_resource(dev, option_flags, p->address.minimum,
445 p->address.minimum, 0, p->address.address_length,
446 IORESOURCE_IO_FIXED);
447 }
448
449 struct acpipnp_parse_option_s {
450 struct pnp_dev *dev;
451 unsigned int option_flags;
452 };
453
pnpacpi_option_resource(struct acpi_resource * res,void * data)454 static __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, &res->data.irq);
465 break;
466
467 case ACPI_RESOURCE_TYPE_DMA:
468 pnpacpi_parse_dma_option(dev, option_flags, &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, &res->data.io);
497 break;
498
499 case ACPI_RESOURCE_TYPE_FIXED_IO:
500 pnpacpi_parse_fixed_port_option(dev, option_flags,
501 &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 &res->data.memory24);
511 break;
512
513 case ACPI_RESOURCE_TYPE_MEMORY32:
514 pnpacpi_parse_mem32_option(dev, option_flags,
515 &res->data.memory32);
516 break;
517
518 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
519 pnpacpi_parse_fixed_mem32_option(dev, option_flags,
520 &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, res);
527 break;
528
529 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
530 pnpacpi_parse_ext_address_option(dev, option_flags, res);
531 break;
532
533 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
534 pnpacpi_parse_ext_irq_option(dev, option_flags,
535 &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
pnpacpi_parse_resource_option_data(struct pnp_dev * dev)550 int __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(handle, METHOD_NAME__PRS,
563 pnpacpi_option_resource, &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
pnpacpi_supported_resource(struct acpi_resource * res)573 static 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 */
pnpacpi_count_resources(struct acpi_resource * res,void * data)596 static 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
pnpacpi_type_resources(struct acpi_resource * res,void * data)606 static 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
pnpacpi_build_resource_template(struct pnp_dev * dev,struct acpi_buffer * buffer)622 int 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(handle, METHOD_NAME__CRS,
632 pnpacpi_count_resources, &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(handle, METHOD_NAME__CRS,
646 pnpacpi_type_resources, &resource);
647 if (ACPI_FAILURE(status)) {
648 kfree(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
pnpacpi_encode_irq(struct pnp_dev * dev,struct acpi_resource * resource,struct resource * p)659 static 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(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, p->flags, &triggering, &polarity, &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
pnpacpi_encode_ext_irq(struct pnp_dev * dev,struct acpi_resource * resource,struct resource * p)688 static 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(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, p->flags, &triggering, &polarity, &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
pnpacpi_encode_dma(struct pnp_dev * dev,struct acpi_resource * resource,struct resource * p)716 static 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(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
pnpacpi_encode_io(struct pnp_dev * dev,struct acpi_resource * resource,struct resource * p)764 static 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(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(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
pnpacpi_encode_fixed_io(struct pnp_dev * dev,struct acpi_resource * resource,struct resource * p)787 static 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(p)) {
794 fixed_io->address = p->start;
795 fixed_io->address_length = resource_size(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
pnpacpi_encode_mem24(struct pnp_dev * dev,struct acpi_resource * resource,struct resource * p)805 static 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(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(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
pnpacpi_encode_mem32(struct pnp_dev * dev,struct acpi_resource * resource,struct resource * p)830 static 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(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(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
pnpacpi_encode_fixed_mem32(struct pnp_dev * dev,struct acpi_resource * resource,struct resource * p)854 static 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(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(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
pnpacpi_encode_resources(struct pnp_dev * dev,struct acpi_buffer * buffer)877 int 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 pnp_get_resource(dev, IORESOURCE_IRQ, irq));
891 irq++;
892 break;
893
894 case ACPI_RESOURCE_TYPE_DMA:
895 pnpacpi_encode_dma(dev, resource,
896 pnp_get_resource(dev, IORESOURCE_DMA, dma));
897 dma++;
898 break;
899 case ACPI_RESOURCE_TYPE_IO:
900 pnpacpi_encode_io(dev, resource,
901 pnp_get_resource(dev, IORESOURCE_IO, port));
902 port++;
903 break;
904 case ACPI_RESOURCE_TYPE_FIXED_IO:
905 pnpacpi_encode_fixed_io(dev, resource,
906 pnp_get_resource(dev, IORESOURCE_IO, port));
907 port++;
908 break;
909 case ACPI_RESOURCE_TYPE_MEMORY24:
910 pnpacpi_encode_mem24(dev, resource,
911 pnp_get_resource(dev, IORESOURCE_MEM, mem));
912 mem++;
913 break;
914 case ACPI_RESOURCE_TYPE_MEMORY32:
915 pnpacpi_encode_mem32(dev, resource,
916 pnp_get_resource(dev, IORESOURCE_MEM, mem));
917 mem++;
918 break;
919 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
920 pnpacpi_encode_fixed_mem32(dev, resource,
921 pnp_get_resource(dev, IORESOURCE_MEM, mem));
922 mem++;
923 break;
924 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
925 pnpacpi_encode_ext_irq(dev, resource,
926 pnp_get_resource(dev, IORESOURCE_IRQ, 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