1 /*
2 * pnpacpi -- PnP ACPI driver
3 *
4 * Copyright (c) 2004 Matthieu Castet <castet.matthieu@free.fr>
5 * Copyright (c) 2004 Li Shaohua <shaohua.li@intel.com>
6 * Copyright (C) 2008 Hewlett-Packard Development Company, L.P.
7 * Bjorn Helgaas <bjorn.helgaas@hp.com>
8 *
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the
11 * Free Software Foundation; either version 2, or (at your option) any
12 * later version.
13 *
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
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
decode_irq_flags(struct pnp_dev * dev,int flags,u8 * triggering,u8 * polarity,u8 * shareable)31 static 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
dma_flags(struct pnp_dev * dev,int type,int bus_master,int transfer)66 static 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 /* Set a default value ? */
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 /* Set a default value ? */
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 * Allocated Resources
112 */
113
pnpacpi_add_irqresource(struct pnp_dev * dev,struct resource * r)114 static 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 * Device CSRs that do not appear in PCI config space should be described
124 * via ACPI. This would normally be done with Address Space Descriptors
125 * marked as "consumer-only," but old versions of Windows and Linux ignore
126 * the producer/consumer flag, so HP invented a vendor-defined resource to
127 * describe the location and size of CSR space.
128 */
129 static 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
vendor_resource_matches(struct pnp_dev * dev,struct acpi_resource_vendor_typed * vendor,struct acpi_vendor_uuid * match,int expected_len)135 static 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 /* byte_length includes uuid_subtype and uuid */
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
pnpacpi_parse_allocated_vendor(struct pnp_dev * dev,struct acpi_resource_vendor_typed * vendor)164 static 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
pnpacpi_allocated_resource(struct acpi_resource * res,void * data)177 static 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 * The IRQ encoder puts a single interrupt in each
202 * descriptor, so if a _CRS descriptor has more than
203 * one interrupt, we won't be able to re-encode it.
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 /* serial bus connections (I2C/SPI/UART) are not pnp */
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
pnpacpi_parse_allocated_resource(struct pnp_dev * dev)268 int 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
pnpacpi_parse_dma_option(struct pnp_dev * dev,unsigned int option_flags,struct acpi_resource_dma * p)289 static __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
pnpacpi_parse_irq_option(struct pnp_dev * dev,unsigned int option_flags,struct acpi_resource_irq * p)303 static __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
pnpacpi_parse_ext_irq_option(struct pnp_dev * dev,unsigned int option_flags,struct acpi_resource_extended_irq * p)320 static __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
pnpacpi_parse_port_option(struct pnp_dev * dev,unsigned int option_flags,struct acpi_resource_io * io)344 static __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
pnpacpi_parse_fixed_port_option(struct pnp_dev * dev,unsigned int option_flags,struct acpi_resource_fixed_io * io)356 static __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
pnpacpi_parse_mem24_option(struct pnp_dev * dev,unsigned int option_flags,struct acpi_resource_memory24 * p)364 static __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
pnpacpi_parse_mem32_option(struct pnp_dev * dev,unsigned int option_flags,struct acpi_resource_memory32 * p)376 static __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
pnpacpi_parse_fixed_mem32_option(struct pnp_dev * dev,unsigned int option_flags,struct acpi_resource_fixed_memory32 * p)388 static __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
pnpacpi_parse_address_option(struct pnp_dev * dev,unsigned int option_flags,struct acpi_resource * r)400 static __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
pnpacpi_parse_ext_address_option(struct pnp_dev * dev,unsigned int option_flags,struct acpi_resource * r)427 static __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
446 struct acpipnp_parse_option_s {
447 struct pnp_dev *dev;
448 unsigned int option_flags;
449 };
450
pnpacpi_option_resource(struct acpi_resource * res,void * data)451 static __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
pnpacpi_parse_resource_option_data(struct pnp_dev * dev)547 int __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
pnpacpi_supported_resource(struct acpi_resource * res)570 static 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 * Set resource
592 */
pnpacpi_count_resources(struct acpi_resource * res,void * data)593 static 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
pnpacpi_type_resources(struct acpi_resource * res,void * data)603 static 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
pnpacpi_build_resource_template(struct pnp_dev * dev,struct acpi_buffer * buffer)619 int 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 /* resource will pointer the end resource now */
650 resource->type = ACPI_RESOURCE_TYPE_END_TAG;
651 resource->length = sizeof(struct acpi_resource);
652
653 return 0;
654 }
655
pnpacpi_encode_irq(struct pnp_dev * dev,struct acpi_resource * resource,struct resource * p)656 static 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
pnpacpi_encode_ext_irq(struct pnp_dev * dev,struct acpi_resource * resource,struct resource * p)685 static 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
pnpacpi_encode_dma(struct pnp_dev * dev,struct acpi_resource * resource,struct resource * p)713 static 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 /* Note: pnp_assign_dma will copy pnp_dma->flags into p->flags */
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
pnpacpi_encode_io(struct pnp_dev * dev,struct acpi_resource * resource,struct resource * p)761 static 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 /* Note: pnp_assign_port copies pnp_port->flags into p->flags */
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; /* Correct? */
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
pnpacpi_encode_fixed_io(struct pnp_dev * dev,struct acpi_resource * resource,struct resource * p)784 static 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
pnpacpi_encode_mem24(struct pnp_dev * dev,struct acpi_resource * resource,struct resource * p)802 static 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 /* Note: pnp_assign_mem copies pnp_mem->flags into p->flags */
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
pnpacpi_encode_mem32(struct pnp_dev * dev,struct acpi_resource * resource,struct resource * p)827 static 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
pnpacpi_encode_fixed_mem32(struct pnp_dev * dev,struct acpi_resource * resource,struct resource * p)851 static 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
pnpacpi_encode_resources(struct pnp_dev * dev,struct acpi_buffer * buffer)874 int pnpacpi_encode_resources(struct pnp_dev *dev, struct acpi_buffer *buffer)
875 {
876 int i = 0;
877 /* pnpacpi_build_resource_template allocates extra mem */
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: /* other type */
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