pnpacpi: print resource shortage message only once (more)
[linux-2.6.git] / drivers / pnp / pnpacpi / rsparser.c
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  *
7  * This program is free software; you can redistribute it and/or modify it
8  * under the terms of the GNU General Public License as published by the
9  * Free Software Foundation; either version 2, or (at your option) any
10  * later version.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20  */
21 #include <linux/kernel.h>
22 #include <linux/acpi.h>
23 #include <linux/pci.h>
24 #include "pnpacpi.h"
25
26 #ifdef CONFIG_IA64
27 #define valid_IRQ(i) (1)
28 #else
29 #define valid_IRQ(i) (((i) != 0) && ((i) != 2))
30 #endif
31
32 /*
33  * Allocated Resources
34  */
35 static int irq_flags(int triggering, int polarity)
36 {
37         if (triggering == ACPI_LEVEL_SENSITIVE) {
38                 if (polarity == ACPI_ACTIVE_LOW)
39                         return IORESOURCE_IRQ_LOWLEVEL;
40                 else
41                         return IORESOURCE_IRQ_HIGHLEVEL;
42         } else {
43                 if (polarity == ACPI_ACTIVE_LOW)
44                         return IORESOURCE_IRQ_LOWEDGE;
45                 else
46                         return IORESOURCE_IRQ_HIGHEDGE;
47         }
48 }
49
50 static void decode_irq_flags(int flag, int *triggering, int *polarity)
51 {
52         switch (flag) {
53         case IORESOURCE_IRQ_LOWLEVEL:
54                 *triggering = ACPI_LEVEL_SENSITIVE;
55                 *polarity = ACPI_ACTIVE_LOW;
56                 break;
57         case IORESOURCE_IRQ_HIGHLEVEL:
58                 *triggering = ACPI_LEVEL_SENSITIVE;
59                 *polarity = ACPI_ACTIVE_HIGH;
60                 break;
61         case IORESOURCE_IRQ_LOWEDGE:
62                 *triggering = ACPI_EDGE_SENSITIVE;
63                 *polarity = ACPI_ACTIVE_LOW;
64                 break;
65         case IORESOURCE_IRQ_HIGHEDGE:
66                 *triggering = ACPI_EDGE_SENSITIVE;
67                 *polarity = ACPI_ACTIVE_HIGH;
68                 break;
69         }
70 }
71
72 static void pnpacpi_parse_allocated_irqresource(struct pnp_resource_table *res,
73                                                 u32 gsi, int triggering,
74                                                 int polarity, int shareable)
75 {
76         int i = 0;
77         int irq;
78         int p, t;
79         static unsigned char warned;
80
81         if (!valid_IRQ(gsi))
82                 return;
83
84         while (!(res->irq_resource[i].flags & IORESOURCE_UNSET) &&
85                i < PNP_MAX_IRQ)
86                 i++;
87         if (i >= PNP_MAX_IRQ && !warned) {
88                 printk(KERN_ERR "pnpacpi: exceeded the max number of IRQ "
89                                 "resources: %d \n", PNP_MAX_IRQ);
90                 warned = 1;
91                 return;
92         }
93         /*
94          * in IO-APIC mode, use overrided attribute. Two reasons:
95          * 1. BIOS bug in DSDT
96          * 2. BIOS uses IO-APIC mode Interrupt Source Override
97          */
98         if (!acpi_get_override_irq(gsi, &t, &p)) {
99                 t = t ? ACPI_LEVEL_SENSITIVE : ACPI_EDGE_SENSITIVE;
100                 p = p ? ACPI_ACTIVE_LOW : ACPI_ACTIVE_HIGH;
101
102                 if (triggering != t || polarity != p) {
103                         pnp_warn("IRQ %d override to %s, %s",
104                                 gsi, t ? "edge":"level", p ? "low":"high");
105                         triggering = t;
106                         polarity = p;
107                 }
108         }
109
110         res->irq_resource[i].flags = IORESOURCE_IRQ;    // Also clears _UNSET flag
111         res->irq_resource[i].flags |= irq_flags(triggering, polarity);
112         irq = acpi_register_gsi(gsi, triggering, polarity);
113         if (irq < 0) {
114                 res->irq_resource[i].flags |= IORESOURCE_DISABLED;
115                 return;
116         }
117
118         if (shareable)
119                 res->irq_resource[i].flags |= IORESOURCE_IRQ_SHAREABLE;
120
121         res->irq_resource[i].start = irq;
122         res->irq_resource[i].end = irq;
123         pcibios_penalize_isa_irq(irq, 1);
124 }
125
126 static int dma_flags(int type, int bus_master, int transfer)
127 {
128         int flags = 0;
129
130         if (bus_master)
131                 flags |= IORESOURCE_DMA_MASTER;
132         switch (type) {
133         case ACPI_COMPATIBILITY:
134                 flags |= IORESOURCE_DMA_COMPATIBLE;
135                 break;
136         case ACPI_TYPE_A:
137                 flags |= IORESOURCE_DMA_TYPEA;
138                 break;
139         case ACPI_TYPE_B:
140                 flags |= IORESOURCE_DMA_TYPEB;
141                 break;
142         case ACPI_TYPE_F:
143                 flags |= IORESOURCE_DMA_TYPEF;
144                 break;
145         default:
146                 /* Set a default value ? */
147                 flags |= IORESOURCE_DMA_COMPATIBLE;
148                 pnp_err("Invalid DMA type");
149         }
150         switch (transfer) {
151         case ACPI_TRANSFER_8:
152                 flags |= IORESOURCE_DMA_8BIT;
153                 break;
154         case ACPI_TRANSFER_8_16:
155                 flags |= IORESOURCE_DMA_8AND16BIT;
156                 break;
157         case ACPI_TRANSFER_16:
158                 flags |= IORESOURCE_DMA_16BIT;
159                 break;
160         default:
161                 /* Set a default value ? */
162                 flags |= IORESOURCE_DMA_8AND16BIT;
163                 pnp_err("Invalid DMA transfer type");
164         }
165
166         return flags;
167 }
168
169 static void pnpacpi_parse_allocated_dmaresource(struct pnp_resource_table *res,
170                                                 u32 dma, int type,
171                                                 int bus_master, int transfer)
172 {
173         int i = 0;
174         static unsigned char warned;
175
176         while (i < PNP_MAX_DMA &&
177                !(res->dma_resource[i].flags & IORESOURCE_UNSET))
178                 i++;
179         if (i < PNP_MAX_DMA) {
180                 res->dma_resource[i].flags = IORESOURCE_DMA;    // Also clears _UNSET flag
181                 res->dma_resource[i].flags |=
182                     dma_flags(type, bus_master, transfer);
183                 if (dma == -1) {
184                         res->dma_resource[i].flags |= IORESOURCE_DISABLED;
185                         return;
186                 }
187                 res->dma_resource[i].start = dma;
188                 res->dma_resource[i].end = dma;
189         } else if (!warned) {
190                 printk(KERN_ERR "pnpacpi: exceeded the max number of DMA "
191                                 "resources: %d \n", PNP_MAX_DMA);
192                 warned = 1;
193         }
194 }
195
196 static void pnpacpi_parse_allocated_ioresource(struct pnp_resource_table *res,
197                                                u64 io, u64 len, int io_decode)
198 {
199         int i = 0;
200         static unsigned char warned;
201
202         while (!(res->port_resource[i].flags & IORESOURCE_UNSET) &&
203                i < PNP_MAX_PORT)
204                 i++;
205         if (i < PNP_MAX_PORT) {
206                 res->port_resource[i].flags = IORESOURCE_IO;    // Also clears _UNSET flag
207                 if (io_decode == ACPI_DECODE_16)
208                         res->port_resource[i].flags |= PNP_PORT_FLAG_16BITADDR;
209                 if (len <= 0 || (io + len - 1) >= 0x10003) {
210                         res->port_resource[i].flags |= IORESOURCE_DISABLED;
211                         return;
212                 }
213                 res->port_resource[i].start = io;
214                 res->port_resource[i].end = io + len - 1;
215         } else if (!warned) {
216                 printk(KERN_ERR "pnpacpi: exceeded the max number of IO "
217                                 "resources: %d \n", PNP_MAX_PORT);
218                 warned = 1;
219         }
220 }
221
222 static void pnpacpi_parse_allocated_memresource(struct pnp_resource_table *res,
223                                                 u64 mem, u64 len,
224                                                 int write_protect)
225 {
226         int i = 0;
227         static unsigned char warned;
228
229         while (!(res->mem_resource[i].flags & IORESOURCE_UNSET) &&
230                (i < PNP_MAX_MEM))
231                 i++;
232         if (i < PNP_MAX_MEM) {
233                 res->mem_resource[i].flags = IORESOURCE_MEM;    // Also clears _UNSET flag
234                 if (len <= 0) {
235                         res->mem_resource[i].flags |= IORESOURCE_DISABLED;
236                         return;
237                 }
238                 if (write_protect == ACPI_READ_WRITE_MEMORY)
239                         res->mem_resource[i].flags |= IORESOURCE_MEM_WRITEABLE;
240
241                 res->mem_resource[i].start = mem;
242                 res->mem_resource[i].end = mem + len - 1;
243         } else if (!warned) {
244                 printk(KERN_ERR "pnpacpi: exceeded the max number of mem "
245                                 "resources: %d\n", PNP_MAX_MEM);
246                 warned = 1;
247         }
248 }
249
250 static void pnpacpi_parse_allocated_address_space(struct pnp_resource_table *res_table,
251                                                   struct acpi_resource *res)
252 {
253         struct acpi_resource_address64 addr, *p = &addr;
254         acpi_status status;
255
256         status = acpi_resource_to_address64(res, p);
257         if (!ACPI_SUCCESS(status)) {
258                 pnp_warn("PnPACPI: failed to convert resource type %d",
259                          res->type);
260                 return;
261         }
262
263         if (p->producer_consumer == ACPI_PRODUCER)
264                 return;
265
266         if (p->resource_type == ACPI_MEMORY_RANGE)
267                 pnpacpi_parse_allocated_memresource(res_table,
268                         p->minimum, p->address_length,
269                         p->info.mem.write_protect);
270         else if (p->resource_type == ACPI_IO_RANGE)
271                 pnpacpi_parse_allocated_ioresource(res_table,
272                         p->minimum, p->address_length,
273                         p->granularity == 0xfff ? ACPI_DECODE_10 :
274                                 ACPI_DECODE_16);
275 }
276
277 static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res,
278                                               void *data)
279 {
280         struct pnp_resource_table *res_table = data;
281         int i;
282
283         switch (res->type) {
284         case ACPI_RESOURCE_TYPE_IRQ:
285                 /*
286                  * Per spec, only one interrupt per descriptor is allowed in
287                  * _CRS, but some firmware violates this, so parse them all.
288                  */
289                 for (i = 0; i < res->data.irq.interrupt_count; i++) {
290                         pnpacpi_parse_allocated_irqresource(res_table,
291                                 res->data.irq.interrupts[i],
292                                 res->data.irq.triggering,
293                                 res->data.irq.polarity,
294                                 res->data.irq.sharable);
295                 }
296                 break;
297
298         case ACPI_RESOURCE_TYPE_DMA:
299                 if (res->data.dma.channel_count > 0)
300                         pnpacpi_parse_allocated_dmaresource(res_table,
301                                 res->data.dma.channels[0],
302                                 res->data.dma.type,
303                                 res->data.dma.bus_master,
304                                 res->data.dma.transfer);
305                 break;
306
307         case ACPI_RESOURCE_TYPE_IO:
308                 pnpacpi_parse_allocated_ioresource(res_table,
309                         res->data.io.minimum,
310                         res->data.io.address_length,
311                         res->data.io.io_decode);
312                 break;
313
314         case ACPI_RESOURCE_TYPE_START_DEPENDENT:
315         case ACPI_RESOURCE_TYPE_END_DEPENDENT:
316                 break;
317
318         case ACPI_RESOURCE_TYPE_FIXED_IO:
319                 pnpacpi_parse_allocated_ioresource(res_table,
320                         res->data.fixed_io.address,
321                         res->data.fixed_io.address_length,
322                         ACPI_DECODE_10);
323                 break;
324
325         case ACPI_RESOURCE_TYPE_VENDOR:
326                 break;
327
328         case ACPI_RESOURCE_TYPE_END_TAG:
329                 break;
330
331         case ACPI_RESOURCE_TYPE_MEMORY24:
332                 pnpacpi_parse_allocated_memresource(res_table,
333                         res->data.memory24.minimum,
334                         res->data.memory24.address_length,
335                         res->data.memory24.write_protect);
336                 break;
337         case ACPI_RESOURCE_TYPE_MEMORY32:
338                 pnpacpi_parse_allocated_memresource(res_table,
339                         res->data.memory32.minimum,
340                         res->data.memory32.address_length,
341                         res->data.memory32.write_protect);
342                 break;
343         case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
344                 pnpacpi_parse_allocated_memresource(res_table,
345                         res->data.fixed_memory32.address,
346                         res->data.fixed_memory32.address_length,
347                         res->data.fixed_memory32.write_protect);
348                 break;
349         case ACPI_RESOURCE_TYPE_ADDRESS16:
350         case ACPI_RESOURCE_TYPE_ADDRESS32:
351         case ACPI_RESOURCE_TYPE_ADDRESS64:
352                 pnpacpi_parse_allocated_address_space(res_table, res);
353                 break;
354
355         case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
356                 if (res->data.ext_address64.producer_consumer == ACPI_PRODUCER)
357                         return AE_OK;
358                 break;
359
360         case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
361                 if (res->data.extended_irq.producer_consumer == ACPI_PRODUCER)
362                         return AE_OK;
363
364                 for (i = 0; i < res->data.extended_irq.interrupt_count; i++) {
365                         pnpacpi_parse_allocated_irqresource(res_table,
366                                 res->data.extended_irq.interrupts[i],
367                                 res->data.extended_irq.triggering,
368                                 res->data.extended_irq.polarity,
369                                 res->data.extended_irq.sharable);
370                 }
371                 break;
372
373         case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
374                 break;
375
376         default:
377                 pnp_warn("PnPACPI: unknown resource type %d", res->type);
378                 return AE_ERROR;
379         }
380
381         return AE_OK;
382 }
383
384 acpi_status pnpacpi_parse_allocated_resource(acpi_handle handle,
385                                              struct pnp_resource_table * res)
386 {
387         /* Blank the resource table values */
388         pnp_init_resource_table(res);
389
390         return acpi_walk_resources(handle, METHOD_NAME__CRS,
391                                    pnpacpi_allocated_resource, res);
392 }
393
394 static void pnpacpi_parse_dma_option(struct pnp_option *option,
395                                      struct acpi_resource_dma *p)
396 {
397         int i;
398         struct pnp_dma *dma;
399
400         if (p->channel_count == 0)
401                 return;
402         dma = kzalloc(sizeof(struct pnp_dma), GFP_KERNEL);
403         if (!dma)
404                 return;
405
406         for (i = 0; i < p->channel_count; i++)
407                 dma->map |= 1 << p->channels[i];
408
409         dma->flags = dma_flags(p->type, p->bus_master, p->transfer);
410
411         pnp_register_dma_resource(option, dma);
412 }
413
414 static void pnpacpi_parse_irq_option(struct pnp_option *option,
415                                      struct acpi_resource_irq *p)
416 {
417         int i;
418         struct pnp_irq *irq;
419
420         if (p->interrupt_count == 0)
421                 return;
422         irq = kzalloc(sizeof(struct pnp_irq), GFP_KERNEL);
423         if (!irq)
424                 return;
425
426         for (i = 0; i < p->interrupt_count; i++)
427                 if (p->interrupts[i])
428                         __set_bit(p->interrupts[i], irq->map);
429         irq->flags = irq_flags(p->triggering, p->polarity);
430
431         pnp_register_irq_resource(option, irq);
432 }
433
434 static void pnpacpi_parse_ext_irq_option(struct pnp_option *option,
435                                          struct acpi_resource_extended_irq *p)
436 {
437         int i;
438         struct pnp_irq *irq;
439
440         if (p->interrupt_count == 0)
441                 return;
442         irq = kzalloc(sizeof(struct pnp_irq), GFP_KERNEL);
443         if (!irq)
444                 return;
445
446         for (i = 0; i < p->interrupt_count; i++)
447                 if (p->interrupts[i])
448                         __set_bit(p->interrupts[i], irq->map);
449         irq->flags = irq_flags(p->triggering, p->polarity);
450
451         pnp_register_irq_resource(option, irq);
452 }
453
454 static void pnpacpi_parse_port_option(struct pnp_option *option,
455                                       struct acpi_resource_io *io)
456 {
457         struct pnp_port *port;
458
459         if (io->address_length == 0)
460                 return;
461         port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL);
462         if (!port)
463                 return;
464         port->min = io->minimum;
465         port->max = io->maximum;
466         port->align = io->alignment;
467         port->size = io->address_length;
468         port->flags = ACPI_DECODE_16 == io->io_decode ?
469             PNP_PORT_FLAG_16BITADDR : 0;
470         pnp_register_port_resource(option, port);
471 }
472
473 static void pnpacpi_parse_fixed_port_option(struct pnp_option *option,
474                                             struct acpi_resource_fixed_io *io)
475 {
476         struct pnp_port *port;
477
478         if (io->address_length == 0)
479                 return;
480         port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL);
481         if (!port)
482                 return;
483         port->min = port->max = io->address;
484         port->size = io->address_length;
485         port->align = 0;
486         port->flags = PNP_PORT_FLAG_FIXED;
487         pnp_register_port_resource(option, port);
488 }
489
490 static void pnpacpi_parse_mem24_option(struct pnp_option *option,
491                                        struct acpi_resource_memory24 *p)
492 {
493         struct pnp_mem *mem;
494
495         if (p->address_length == 0)
496                 return;
497         mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
498         if (!mem)
499                 return;
500         mem->min = p->minimum;
501         mem->max = p->maximum;
502         mem->align = p->alignment;
503         mem->size = p->address_length;
504
505         mem->flags = (ACPI_READ_WRITE_MEMORY == p->write_protect) ?
506             IORESOURCE_MEM_WRITEABLE : 0;
507
508         pnp_register_mem_resource(option, mem);
509 }
510
511 static void pnpacpi_parse_mem32_option(struct pnp_option *option,
512                                        struct acpi_resource_memory32 *p)
513 {
514         struct pnp_mem *mem;
515
516         if (p->address_length == 0)
517                 return;
518         mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
519         if (!mem)
520                 return;
521         mem->min = p->minimum;
522         mem->max = p->maximum;
523         mem->align = p->alignment;
524         mem->size = p->address_length;
525
526         mem->flags = (ACPI_READ_WRITE_MEMORY == p->write_protect) ?
527             IORESOURCE_MEM_WRITEABLE : 0;
528
529         pnp_register_mem_resource(option, mem);
530 }
531
532 static void pnpacpi_parse_fixed_mem32_option(struct pnp_option *option,
533                                          struct acpi_resource_fixed_memory32 *p)
534 {
535         struct pnp_mem *mem;
536
537         if (p->address_length == 0)
538                 return;
539         mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
540         if (!mem)
541                 return;
542         mem->min = mem->max = p->address;
543         mem->size = p->address_length;
544         mem->align = 0;
545
546         mem->flags = (ACPI_READ_WRITE_MEMORY == p->write_protect) ?
547             IORESOURCE_MEM_WRITEABLE : 0;
548
549         pnp_register_mem_resource(option, mem);
550 }
551
552 static void pnpacpi_parse_address_option(struct pnp_option *option,
553                                          struct acpi_resource *r)
554 {
555         struct acpi_resource_address64 addr, *p = &addr;
556         acpi_status status;
557         struct pnp_mem *mem;
558         struct pnp_port *port;
559
560         status = acpi_resource_to_address64(r, p);
561         if (!ACPI_SUCCESS(status)) {
562                 pnp_warn("PnPACPI: failed to convert resource type %d",
563                          r->type);
564                 return;
565         }
566
567         if (p->address_length == 0)
568                 return;
569
570         if (p->resource_type == ACPI_MEMORY_RANGE) {
571                 mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
572                 if (!mem)
573                         return;
574                 mem->min = mem->max = p->minimum;
575                 mem->size = p->address_length;
576                 mem->align = 0;
577                 mem->flags = (p->info.mem.write_protect ==
578                               ACPI_READ_WRITE_MEMORY) ? IORESOURCE_MEM_WRITEABLE
579                     : 0;
580                 pnp_register_mem_resource(option, mem);
581         } else if (p->resource_type == ACPI_IO_RANGE) {
582                 port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL);
583                 if (!port)
584                         return;
585                 port->min = port->max = p->minimum;
586                 port->size = p->address_length;
587                 port->align = 0;
588                 port->flags = PNP_PORT_FLAG_FIXED;
589                 pnp_register_port_resource(option, port);
590         }
591 }
592
593 struct acpipnp_parse_option_s {
594         struct pnp_option *option;
595         struct pnp_option *option_independent;
596         struct pnp_dev *dev;
597 };
598
599 static acpi_status pnpacpi_option_resource(struct acpi_resource *res,
600                                            void *data)
601 {
602         int priority = 0;
603         struct acpipnp_parse_option_s *parse_data = data;
604         struct pnp_dev *dev = parse_data->dev;
605         struct pnp_option *option = parse_data->option;
606
607         switch (res->type) {
608         case ACPI_RESOURCE_TYPE_IRQ:
609                 pnpacpi_parse_irq_option(option, &res->data.irq);
610                 break;
611
612         case ACPI_RESOURCE_TYPE_DMA:
613                 pnpacpi_parse_dma_option(option, &res->data.dma);
614                 break;
615
616         case ACPI_RESOURCE_TYPE_START_DEPENDENT:
617                 switch (res->data.start_dpf.compatibility_priority) {
618                 case ACPI_GOOD_CONFIGURATION:
619                         priority = PNP_RES_PRIORITY_PREFERRED;
620                         break;
621
622                 case ACPI_ACCEPTABLE_CONFIGURATION:
623                         priority = PNP_RES_PRIORITY_ACCEPTABLE;
624                         break;
625
626                 case ACPI_SUB_OPTIMAL_CONFIGURATION:
627                         priority = PNP_RES_PRIORITY_FUNCTIONAL;
628                         break;
629                 default:
630                         priority = PNP_RES_PRIORITY_INVALID;
631                         break;
632                 }
633                 /* TBD: Consider performance/robustness bits */
634                 option = pnp_register_dependent_option(dev, priority);
635                 if (!option)
636                         return AE_ERROR;
637                 parse_data->option = option;
638                 break;
639
640         case ACPI_RESOURCE_TYPE_END_DEPENDENT:
641                 /*only one EndDependentFn is allowed */
642                 if (!parse_data->option_independent) {
643                         pnp_warn("PnPACPI: more than one EndDependentFn");
644                         return AE_ERROR;
645                 }
646                 parse_data->option = parse_data->option_independent;
647                 parse_data->option_independent = NULL;
648                 break;
649
650         case ACPI_RESOURCE_TYPE_IO:
651                 pnpacpi_parse_port_option(option, &res->data.io);
652                 break;
653
654         case ACPI_RESOURCE_TYPE_FIXED_IO:
655                 pnpacpi_parse_fixed_port_option(option, &res->data.fixed_io);
656                 break;
657
658         case ACPI_RESOURCE_TYPE_VENDOR:
659         case ACPI_RESOURCE_TYPE_END_TAG:
660                 break;
661
662         case ACPI_RESOURCE_TYPE_MEMORY24:
663                 pnpacpi_parse_mem24_option(option, &res->data.memory24);
664                 break;
665
666         case ACPI_RESOURCE_TYPE_MEMORY32:
667                 pnpacpi_parse_mem32_option(option, &res->data.memory32);
668                 break;
669
670         case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
671                 pnpacpi_parse_fixed_mem32_option(option,
672                                                  &res->data.fixed_memory32);
673                 break;
674
675         case ACPI_RESOURCE_TYPE_ADDRESS16:
676         case ACPI_RESOURCE_TYPE_ADDRESS32:
677         case ACPI_RESOURCE_TYPE_ADDRESS64:
678                 pnpacpi_parse_address_option(option, res);
679                 break;
680
681         case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
682                 break;
683
684         case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
685                 pnpacpi_parse_ext_irq_option(option, &res->data.extended_irq);
686                 break;
687
688         case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
689                 break;
690
691         default:
692                 pnp_warn("PnPACPI: unknown resource type %d", res->type);
693                 return AE_ERROR;
694         }
695
696         return AE_OK;
697 }
698
699 acpi_status pnpacpi_parse_resource_option_data(acpi_handle handle,
700                                                struct pnp_dev * dev)
701 {
702         acpi_status status;
703         struct acpipnp_parse_option_s parse_data;
704
705         parse_data.option = pnp_register_independent_option(dev);
706         if (!parse_data.option)
707                 return AE_ERROR;
708         parse_data.option_independent = parse_data.option;
709         parse_data.dev = dev;
710         status = acpi_walk_resources(handle, METHOD_NAME__PRS,
711                                      pnpacpi_option_resource, &parse_data);
712
713         return status;
714 }
715
716 static int pnpacpi_supported_resource(struct acpi_resource *res)
717 {
718         switch (res->type) {
719         case ACPI_RESOURCE_TYPE_IRQ:
720         case ACPI_RESOURCE_TYPE_DMA:
721         case ACPI_RESOURCE_TYPE_IO:
722         case ACPI_RESOURCE_TYPE_FIXED_IO:
723         case ACPI_RESOURCE_TYPE_MEMORY24:
724         case ACPI_RESOURCE_TYPE_MEMORY32:
725         case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
726         case ACPI_RESOURCE_TYPE_ADDRESS16:
727         case ACPI_RESOURCE_TYPE_ADDRESS32:
728         case ACPI_RESOURCE_TYPE_ADDRESS64:
729         case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
730                 return 1;
731         }
732         return 0;
733 }
734
735 /*
736  * Set resource
737  */
738 static acpi_status pnpacpi_count_resources(struct acpi_resource *res,
739                                            void *data)
740 {
741         int *res_cnt = data;
742
743         if (pnpacpi_supported_resource(res))
744                 (*res_cnt)++;
745         return AE_OK;
746 }
747
748 static acpi_status pnpacpi_type_resources(struct acpi_resource *res, void *data)
749 {
750         struct acpi_resource **resource = data;
751
752         if (pnpacpi_supported_resource(res)) {
753                 (*resource)->type = res->type;
754                 (*resource)->length = sizeof(struct acpi_resource);
755                 (*resource)++;
756         }
757
758         return AE_OK;
759 }
760
761 int pnpacpi_build_resource_template(acpi_handle handle,
762                                     struct acpi_buffer *buffer)
763 {
764         struct acpi_resource *resource;
765         int res_cnt = 0;
766         acpi_status status;
767
768         status = acpi_walk_resources(handle, METHOD_NAME__CRS,
769                                      pnpacpi_count_resources, &res_cnt);
770         if (ACPI_FAILURE(status)) {
771                 pnp_err("Evaluate _CRS failed");
772                 return -EINVAL;
773         }
774         if (!res_cnt)
775                 return -EINVAL;
776         buffer->length = sizeof(struct acpi_resource) * (res_cnt + 1) + 1;
777         buffer->pointer = kzalloc(buffer->length - 1, GFP_KERNEL);
778         if (!buffer->pointer)
779                 return -ENOMEM;
780         pnp_dbg("Res cnt %d", res_cnt);
781         resource = (struct acpi_resource *)buffer->pointer;
782         status = acpi_walk_resources(handle, METHOD_NAME__CRS,
783                                      pnpacpi_type_resources, &resource);
784         if (ACPI_FAILURE(status)) {
785                 kfree(buffer->pointer);
786                 pnp_err("Evaluate _CRS failed");
787                 return -EINVAL;
788         }
789         /* resource will pointer the end resource now */
790         resource->type = ACPI_RESOURCE_TYPE_END_TAG;
791
792         return 0;
793 }
794
795 static void pnpacpi_encode_irq(struct acpi_resource *resource,
796                                struct resource *p)
797 {
798         int triggering, polarity;
799
800         decode_irq_flags(p->flags & IORESOURCE_BITS, &triggering, &polarity);
801         resource->data.irq.triggering = triggering;
802         resource->data.irq.polarity = polarity;
803         if (triggering == ACPI_EDGE_SENSITIVE)
804                 resource->data.irq.sharable = ACPI_EXCLUSIVE;
805         else
806                 resource->data.irq.sharable = ACPI_SHARED;
807         resource->data.irq.interrupt_count = 1;
808         resource->data.irq.interrupts[0] = p->start;
809 }
810
811 static void pnpacpi_encode_ext_irq(struct acpi_resource *resource,
812                                    struct resource *p)
813 {
814         int triggering, polarity;
815
816         decode_irq_flags(p->flags & IORESOURCE_BITS, &triggering, &polarity);
817         resource->data.extended_irq.producer_consumer = ACPI_CONSUMER;
818         resource->data.extended_irq.triggering = triggering;
819         resource->data.extended_irq.polarity = polarity;
820         if (triggering == ACPI_EDGE_SENSITIVE)
821                 resource->data.irq.sharable = ACPI_EXCLUSIVE;
822         else
823                 resource->data.irq.sharable = ACPI_SHARED;
824         resource->data.extended_irq.interrupt_count = 1;
825         resource->data.extended_irq.interrupts[0] = p->start;
826 }
827
828 static void pnpacpi_encode_dma(struct acpi_resource *resource,
829                                struct resource *p)
830 {
831         /* Note: pnp_assign_dma will copy pnp_dma->flags into p->flags */
832         switch (p->flags & IORESOURCE_DMA_SPEED_MASK) {
833         case IORESOURCE_DMA_TYPEA:
834                 resource->data.dma.type = ACPI_TYPE_A;
835                 break;
836         case IORESOURCE_DMA_TYPEB:
837                 resource->data.dma.type = ACPI_TYPE_B;
838                 break;
839         case IORESOURCE_DMA_TYPEF:
840                 resource->data.dma.type = ACPI_TYPE_F;
841                 break;
842         default:
843                 resource->data.dma.type = ACPI_COMPATIBILITY;
844         }
845
846         switch (p->flags & IORESOURCE_DMA_TYPE_MASK) {
847         case IORESOURCE_DMA_8BIT:
848                 resource->data.dma.transfer = ACPI_TRANSFER_8;
849                 break;
850         case IORESOURCE_DMA_8AND16BIT:
851                 resource->data.dma.transfer = ACPI_TRANSFER_8_16;
852                 break;
853         default:
854                 resource->data.dma.transfer = ACPI_TRANSFER_16;
855         }
856
857         resource->data.dma.bus_master = !!(p->flags & IORESOURCE_DMA_MASTER);
858         resource->data.dma.channel_count = 1;
859         resource->data.dma.channels[0] = p->start;
860 }
861
862 static void pnpacpi_encode_io(struct acpi_resource *resource,
863                               struct resource *p)
864 {
865         /* Note: pnp_assign_port will copy pnp_port->flags into p->flags */
866         resource->data.io.io_decode = (p->flags & PNP_PORT_FLAG_16BITADDR) ?
867             ACPI_DECODE_16 : ACPI_DECODE_10;
868         resource->data.io.minimum = p->start;
869         resource->data.io.maximum = p->end;
870         resource->data.io.alignment = 0;        /* Correct? */
871         resource->data.io.address_length = p->end - p->start + 1;
872 }
873
874 static void pnpacpi_encode_fixed_io(struct acpi_resource *resource,
875                                     struct resource *p)
876 {
877         resource->data.fixed_io.address = p->start;
878         resource->data.fixed_io.address_length = p->end - p->start + 1;
879 }
880
881 static void pnpacpi_encode_mem24(struct acpi_resource *resource,
882                                  struct resource *p)
883 {
884         /* Note: pnp_assign_mem will copy pnp_mem->flags into p->flags */
885         resource->data.memory24.write_protect =
886             (p->flags & IORESOURCE_MEM_WRITEABLE) ?
887             ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
888         resource->data.memory24.minimum = p->start;
889         resource->data.memory24.maximum = p->end;
890         resource->data.memory24.alignment = 0;
891         resource->data.memory24.address_length = p->end - p->start + 1;
892 }
893
894 static void pnpacpi_encode_mem32(struct acpi_resource *resource,
895                                  struct resource *p)
896 {
897         resource->data.memory32.write_protect =
898             (p->flags & IORESOURCE_MEM_WRITEABLE) ?
899             ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
900         resource->data.memory32.minimum = p->start;
901         resource->data.memory32.maximum = p->end;
902         resource->data.memory32.alignment = 0;
903         resource->data.memory32.address_length = p->end - p->start + 1;
904 }
905
906 static void pnpacpi_encode_fixed_mem32(struct acpi_resource *resource,
907                                        struct resource *p)
908 {
909         resource->data.fixed_memory32.write_protect =
910             (p->flags & IORESOURCE_MEM_WRITEABLE) ?
911             ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
912         resource->data.fixed_memory32.address = p->start;
913         resource->data.fixed_memory32.address_length = p->end - p->start + 1;
914 }
915
916 int pnpacpi_encode_resources(struct pnp_resource_table *res_table,
917                              struct acpi_buffer *buffer)
918 {
919         int i = 0;
920         /* pnpacpi_build_resource_template allocates extra mem */
921         int res_cnt = (buffer->length - 1) / sizeof(struct acpi_resource) - 1;
922         struct acpi_resource *resource = buffer->pointer;
923         int port = 0, irq = 0, dma = 0, mem = 0;
924
925         pnp_dbg("res cnt %d", res_cnt);
926         while (i < res_cnt) {
927                 switch (resource->type) {
928                 case ACPI_RESOURCE_TYPE_IRQ:
929                         pnp_dbg("Encode irq");
930                         pnpacpi_encode_irq(resource,
931                                            &res_table->irq_resource[irq]);
932                         irq++;
933                         break;
934
935                 case ACPI_RESOURCE_TYPE_DMA:
936                         pnp_dbg("Encode dma");
937                         pnpacpi_encode_dma(resource,
938                                            &res_table->dma_resource[dma]);
939                         dma++;
940                         break;
941                 case ACPI_RESOURCE_TYPE_IO:
942                         pnp_dbg("Encode io");
943                         pnpacpi_encode_io(resource,
944                                           &res_table->port_resource[port]);
945                         port++;
946                         break;
947                 case ACPI_RESOURCE_TYPE_FIXED_IO:
948                         pnp_dbg("Encode fixed io");
949                         pnpacpi_encode_fixed_io(resource,
950                                                 &res_table->
951                                                 port_resource[port]);
952                         port++;
953                         break;
954                 case ACPI_RESOURCE_TYPE_MEMORY24:
955                         pnp_dbg("Encode mem24");
956                         pnpacpi_encode_mem24(resource,
957                                              &res_table->mem_resource[mem]);
958                         mem++;
959                         break;
960                 case ACPI_RESOURCE_TYPE_MEMORY32:
961                         pnp_dbg("Encode mem32");
962                         pnpacpi_encode_mem32(resource,
963                                              &res_table->mem_resource[mem]);
964                         mem++;
965                         break;
966                 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
967                         pnp_dbg("Encode fixed mem32");
968                         pnpacpi_encode_fixed_mem32(resource,
969                                                    &res_table->
970                                                    mem_resource[mem]);
971                         mem++;
972                         break;
973                 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
974                         pnp_dbg("Encode ext irq");
975                         pnpacpi_encode_ext_irq(resource,
976                                                &res_table->irq_resource[irq]);
977                         irq++;
978                         break;
979                 case ACPI_RESOURCE_TYPE_START_DEPENDENT:
980                 case ACPI_RESOURCE_TYPE_END_DEPENDENT:
981                 case ACPI_RESOURCE_TYPE_VENDOR:
982                 case ACPI_RESOURCE_TYPE_END_TAG:
983                 case ACPI_RESOURCE_TYPE_ADDRESS16:
984                 case ACPI_RESOURCE_TYPE_ADDRESS32:
985                 case ACPI_RESOURCE_TYPE_ADDRESS64:
986                 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
987                 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
988                 default:        /* other type */
989                         pnp_warn("unknown resource type %d", resource->type);
990                         return -EINVAL;
991                 }
992                 resource++;
993                 i++;
994         }
995         return 0;
996 }