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