blob: 1b8f30ff192a919cf72a957453023d9b89a66b64 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * rsparser.c - parses and encodes pnpbios resource data streams
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 */
4
Linus Torvalds1da177e2005-04-16 15:20:36 -07005#include <linux/ctype.h>
6#include <linux/pnp.h>
7#include <linux/pnpbios.h>
Tim Schmielau4e57b682005-10-30 15:03:48 -08008#include <linux/string.h>
9#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070010
11#ifdef CONFIG_PCI
12#include <linux/pci.h>
13#else
Bjorn Helgaas9dd78462007-07-26 10:41:20 -070014inline void pcibios_penalize_isa_irq(int irq, int active)
15{
16}
Bjorn Helgaas07d4e9a2007-07-26 10:41:21 -070017#endif /* CONFIG_PCI */
Linus Torvalds1da177e2005-04-16 15:20:36 -070018
Bjorn Helgaas772defc2008-04-28 16:33:52 -060019#include "../base.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include "pnpbios.h"
21
22/* standard resource tags */
23#define SMALL_TAG_PNPVERNO 0x01
24#define SMALL_TAG_LOGDEVID 0x02
25#define SMALL_TAG_COMPATDEVID 0x03
26#define SMALL_TAG_IRQ 0x04
27#define SMALL_TAG_DMA 0x05
28#define SMALL_TAG_STARTDEP 0x06
29#define SMALL_TAG_ENDDEP 0x07
30#define SMALL_TAG_PORT 0x08
31#define SMALL_TAG_FIXEDPORT 0x09
32#define SMALL_TAG_VENDOR 0x0e
33#define SMALL_TAG_END 0x0f
34#define LARGE_TAG 0x80
35#define LARGE_TAG_MEM 0x81
36#define LARGE_TAG_ANSISTR 0x82
37#define LARGE_TAG_UNICODESTR 0x83
38#define LARGE_TAG_VENDOR 0x84
39#define LARGE_TAG_MEM32 0x85
40#define LARGE_TAG_FIXEDMEM32 0x86
41
42/*
43 * Resource Data Stream Format:
44 *
45 * Allocated Resources (required)
46 * end tag ->
47 * Resource Configuration Options (optional)
48 * end tag ->
49 * Compitable Device IDs (optional)
50 * final end tag ->
51 */
52
53/*
54 * Allocated Resources
55 */
56
Bjorn Helgaas4ab55d82008-04-28 16:34:06 -060057static void pnpbios_parse_allocated_irqresource(struct pnp_dev *dev, int irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -070058{
Bjorn Helgaas4ab55d82008-04-28 16:34:06 -060059 struct pnp_resource_table *res = &dev->res;
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 int i = 0;
Bjorn Helgaas07d4e9a2007-07-26 10:41:21 -070061
Bjorn Helgaas9dd78462007-07-26 10:41:20 -070062 while (!(res->irq_resource[i].flags & IORESOURCE_UNSET)
63 && i < PNP_MAX_IRQ)
64 i++;
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 if (i < PNP_MAX_IRQ) {
Bjorn Helgaas9dd78462007-07-26 10:41:20 -070066 res->irq_resource[i].flags = IORESOURCE_IRQ; // Also clears _UNSET flag
Linus Torvalds1da177e2005-04-16 15:20:36 -070067 if (irq == -1) {
68 res->irq_resource[i].flags |= IORESOURCE_DISABLED;
69 return;
70 }
71 res->irq_resource[i].start =
Bjorn Helgaas9dd78462007-07-26 10:41:20 -070072 res->irq_resource[i].end = (unsigned long)irq;
David Shaohua Lic9c3e452005-04-01 00:07:31 -050073 pcibios_penalize_isa_irq(irq, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -070074 }
75}
76
Bjorn Helgaas4ab55d82008-04-28 16:34:06 -060077static void pnpbios_parse_allocated_dmaresource(struct pnp_dev *dev, int dma)
Linus Torvalds1da177e2005-04-16 15:20:36 -070078{
Bjorn Helgaas4ab55d82008-04-28 16:34:06 -060079 struct pnp_resource_table *res = &dev->res;
Linus Torvalds1da177e2005-04-16 15:20:36 -070080 int i = 0;
Bjorn Helgaas07d4e9a2007-07-26 10:41:21 -070081
Adrian Bunk6e3e98d2005-05-01 08:59:29 -070082 while (i < PNP_MAX_DMA &&
Bjorn Helgaas9dd78462007-07-26 10:41:20 -070083 !(res->dma_resource[i].flags & IORESOURCE_UNSET))
Adrian Bunk6e3e98d2005-05-01 08:59:29 -070084 i++;
Linus Torvalds1da177e2005-04-16 15:20:36 -070085 if (i < PNP_MAX_DMA) {
Bjorn Helgaas9dd78462007-07-26 10:41:20 -070086 res->dma_resource[i].flags = IORESOURCE_DMA; // Also clears _UNSET flag
Linus Torvalds1da177e2005-04-16 15:20:36 -070087 if (dma == -1) {
88 res->dma_resource[i].flags |= IORESOURCE_DISABLED;
89 return;
90 }
91 res->dma_resource[i].start =
Bjorn Helgaas9dd78462007-07-26 10:41:20 -070092 res->dma_resource[i].end = (unsigned long)dma;
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 }
94}
95
Bjorn Helgaas4ab55d82008-04-28 16:34:06 -060096static void pnpbios_parse_allocated_ioresource(struct pnp_dev *dev,
Bjorn Helgaas07d4e9a2007-07-26 10:41:21 -070097 int io, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -070098{
Bjorn Helgaas4ab55d82008-04-28 16:34:06 -060099 struct pnp_resource_table *res = &dev->res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 int i = 0;
Bjorn Helgaas07d4e9a2007-07-26 10:41:21 -0700101
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700102 while (!(res->port_resource[i].flags & IORESOURCE_UNSET)
103 && i < PNP_MAX_PORT)
104 i++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 if (i < PNP_MAX_PORT) {
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700106 res->port_resource[i].flags = IORESOURCE_IO; // Also clears _UNSET flag
107 if (len <= 0 || (io + len - 1) >= 0x10003) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 res->port_resource[i].flags |= IORESOURCE_DISABLED;
109 return;
110 }
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700111 res->port_resource[i].start = (unsigned long)io;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 res->port_resource[i].end = (unsigned long)(io + len - 1);
113 }
114}
115
Bjorn Helgaas4ab55d82008-04-28 16:34:06 -0600116static void pnpbios_parse_allocated_memresource(struct pnp_dev *dev,
Bjorn Helgaas07d4e9a2007-07-26 10:41:21 -0700117 int mem, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118{
Bjorn Helgaas4ab55d82008-04-28 16:34:06 -0600119 struct pnp_resource_table *res = &dev->res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 int i = 0;
Bjorn Helgaas07d4e9a2007-07-26 10:41:21 -0700121
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700122 while (!(res->mem_resource[i].flags & IORESOURCE_UNSET)
123 && i < PNP_MAX_MEM)
124 i++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 if (i < PNP_MAX_MEM) {
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700126 res->mem_resource[i].flags = IORESOURCE_MEM; // Also clears _UNSET flag
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 if (len <= 0) {
128 res->mem_resource[i].flags |= IORESOURCE_DISABLED;
129 return;
130 }
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700131 res->mem_resource[i].start = (unsigned long)mem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 res->mem_resource[i].end = (unsigned long)(mem + len - 1);
133 }
134}
135
Bjorn Helgaas4ab55d82008-04-28 16:34:06 -0600136static unsigned char *pnpbios_parse_allocated_resource_data(struct pnp_dev *dev,
137 unsigned char *p,
138 unsigned char *end)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139{
140 unsigned int len, tag;
141 int io, size, mask, i;
142
143 if (!p)
144 return NULL;
145
146 /* Blank the resource table values */
Bjorn Helgaas4ab55d82008-04-28 16:34:06 -0600147 pnp_init_resource_table(&dev->res);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148
149 while ((char *)p < (char *)end) {
150
151 /* determine the type of tag */
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700152 if (p[0] & LARGE_TAG) { /* large tag */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 len = (p[2] << 8) | p[1];
154 tag = p[0];
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700155 } else { /* small tag */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 len = p[0] & 0x07;
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700157 tag = ((p[0] >> 3) & 0x0f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 }
159
160 switch (tag) {
161
162 case LARGE_TAG_MEM:
163 if (len != 9)
164 goto len_err;
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700165 io = *(short *)&p[4];
166 size = *(short *)&p[10];
Bjorn Helgaas4ab55d82008-04-28 16:34:06 -0600167 pnpbios_parse_allocated_memresource(dev, io, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 break;
169
170 case LARGE_TAG_ANSISTR:
171 /* ignore this for now */
172 break;
173
174 case LARGE_TAG_VENDOR:
175 /* do nothing */
176 break;
177
178 case LARGE_TAG_MEM32:
179 if (len != 17)
180 goto len_err;
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700181 io = *(int *)&p[4];
182 size = *(int *)&p[16];
Bjorn Helgaas4ab55d82008-04-28 16:34:06 -0600183 pnpbios_parse_allocated_memresource(dev, io, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 break;
185
186 case LARGE_TAG_FIXEDMEM32:
187 if (len != 9)
188 goto len_err;
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700189 io = *(int *)&p[4];
190 size = *(int *)&p[8];
Bjorn Helgaas4ab55d82008-04-28 16:34:06 -0600191 pnpbios_parse_allocated_memresource(dev, io, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 break;
193
194 case SMALL_TAG_IRQ:
195 if (len < 2 || len > 3)
196 goto len_err;
197 io = -1;
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700198 mask = p[1] + p[2] * 256;
199 for (i = 0; i < 16; i++, mask = mask >> 1)
200 if (mask & 0x01)
201 io = i;
Bjorn Helgaas4ab55d82008-04-28 16:34:06 -0600202 pnpbios_parse_allocated_irqresource(dev, io);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 break;
204
205 case SMALL_TAG_DMA:
206 if (len != 2)
207 goto len_err;
208 io = -1;
209 mask = p[1];
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700210 for (i = 0; i < 8; i++, mask = mask >> 1)
211 if (mask & 0x01)
212 io = i;
Bjorn Helgaas4ab55d82008-04-28 16:34:06 -0600213 pnpbios_parse_allocated_dmaresource(dev, io);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 break;
215
216 case SMALL_TAG_PORT:
217 if (len != 7)
218 goto len_err;
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700219 io = p[2] + p[3] * 256;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 size = p[7];
Bjorn Helgaas4ab55d82008-04-28 16:34:06 -0600221 pnpbios_parse_allocated_ioresource(dev, io, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 break;
223
224 case SMALL_TAG_VENDOR:
225 /* do nothing */
226 break;
227
228 case SMALL_TAG_FIXEDPORT:
229 if (len != 3)
230 goto len_err;
231 io = p[1] + p[2] * 256;
232 size = p[3];
Bjorn Helgaas4ab55d82008-04-28 16:34:06 -0600233 pnpbios_parse_allocated_ioresource(dev, io, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 break;
235
236 case SMALL_TAG_END:
237 p = p + 2;
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700238 return (unsigned char *)p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 break;
240
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700241 default: /* an unkown tag */
Bjorn Helgaas1e0aa9a2007-08-15 10:32:08 -0600242len_err:
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700243 printk(KERN_ERR
244 "PnPBIOS: Unknown tag '0x%x', length '%d'.\n",
245 tag, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 break;
247 }
248
249 /* continue to the next tag */
250 if (p[0] & LARGE_TAG)
251 p += len + 3;
252 else
253 p += len + 1;
254 }
255
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700256 printk(KERN_ERR
257 "PnPBIOS: Resource structure does not contain an end tag.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258
259 return NULL;
260}
261
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262/*
263 * Resource Configuration Options
264 */
265
Bjorn Helgaasc1caf062008-04-28 16:34:04 -0600266static __init void pnpbios_parse_mem_option(struct pnp_dev *dev,
267 unsigned char *p, int size,
Thomas Renninger2bb9a6b2008-02-06 01:40:03 -0800268 struct pnp_option *option)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269{
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700270 struct pnp_mem *mem;
Bjorn Helgaas07d4e9a2007-07-26 10:41:21 -0700271
Robert P. J. Daycd861282006-12-13 00:34:52 -0800272 mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 if (!mem)
274 return;
275 mem->min = ((p[5] << 8) | p[4]) << 8;
276 mem->max = ((p[7] << 8) | p[6]) << 8;
277 mem->align = (p[9] << 8) | p[8];
278 mem->size = ((p[11] << 8) | p[10]) << 8;
279 mem->flags = p[3];
Bjorn Helgaasc1caf062008-04-28 16:34:04 -0600280 pnp_register_mem_resource(dev, option, mem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281}
282
Bjorn Helgaasc1caf062008-04-28 16:34:04 -0600283static __init void pnpbios_parse_mem32_option(struct pnp_dev *dev,
284 unsigned char *p, int size,
Thomas Renninger2bb9a6b2008-02-06 01:40:03 -0800285 struct pnp_option *option)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286{
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700287 struct pnp_mem *mem;
Bjorn Helgaas07d4e9a2007-07-26 10:41:21 -0700288
Robert P. J. Daycd861282006-12-13 00:34:52 -0800289 mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 if (!mem)
291 return;
292 mem->min = (p[7] << 24) | (p[6] << 16) | (p[5] << 8) | p[4];
293 mem->max = (p[11] << 24) | (p[10] << 16) | (p[9] << 8) | p[8];
294 mem->align = (p[15] << 24) | (p[14] << 16) | (p[13] << 8) | p[12];
295 mem->size = (p[19] << 24) | (p[18] << 16) | (p[17] << 8) | p[16];
296 mem->flags = p[3];
Bjorn Helgaasc1caf062008-04-28 16:34:04 -0600297 pnp_register_mem_resource(dev, option, mem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298}
299
Bjorn Helgaasc1caf062008-04-28 16:34:04 -0600300static __init void pnpbios_parse_fixed_mem32_option(struct pnp_dev *dev,
301 unsigned char *p, int size,
Thomas Renninger2bb9a6b2008-02-06 01:40:03 -0800302 struct pnp_option *option)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303{
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700304 struct pnp_mem *mem;
Bjorn Helgaas1e0aa9a2007-08-15 10:32:08 -0600305
Robert P. J. Daycd861282006-12-13 00:34:52 -0800306 mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 if (!mem)
308 return;
309 mem->min = mem->max = (p[7] << 24) | (p[6] << 16) | (p[5] << 8) | p[4];
310 mem->size = (p[11] << 24) | (p[10] << 16) | (p[9] << 8) | p[8];
311 mem->align = 0;
312 mem->flags = p[3];
Bjorn Helgaasc1caf062008-04-28 16:34:04 -0600313 pnp_register_mem_resource(dev, option, mem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314}
315
Bjorn Helgaasc1caf062008-04-28 16:34:04 -0600316static __init void pnpbios_parse_irq_option(struct pnp_dev *dev,
317 unsigned char *p, int size,
318 struct pnp_option *option)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319{
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700320 struct pnp_irq *irq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 unsigned long bits;
322
Robert P. J. Daycd861282006-12-13 00:34:52 -0800323 irq = kzalloc(sizeof(struct pnp_irq), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 if (!irq)
325 return;
326 bits = (p[2] << 8) | p[1];
327 bitmap_copy(irq->map, &bits, 16);
328 if (size > 2)
329 irq->flags = p[3];
330 else
331 irq->flags = IORESOURCE_IRQ_HIGHEDGE;
Bjorn Helgaasc1caf062008-04-28 16:34:04 -0600332 pnp_register_irq_resource(dev, option, irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333}
334
Bjorn Helgaasc1caf062008-04-28 16:34:04 -0600335static __init void pnpbios_parse_dma_option(struct pnp_dev *dev,
336 unsigned char *p, int size,
337 struct pnp_option *option)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338{
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700339 struct pnp_dma *dma;
Bjorn Helgaas07d4e9a2007-07-26 10:41:21 -0700340
Robert P. J. Daycd861282006-12-13 00:34:52 -0800341 dma = kzalloc(sizeof(struct pnp_dma), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 if (!dma)
343 return;
344 dma->map = p[1];
345 dma->flags = p[2];
Bjorn Helgaasc1caf062008-04-28 16:34:04 -0600346 pnp_register_dma_resource(dev, option, dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347}
348
Bjorn Helgaasc1caf062008-04-28 16:34:04 -0600349static __init void pnpbios_parse_port_option(struct pnp_dev *dev,
350 unsigned char *p, int size,
Thomas Renninger2bb9a6b2008-02-06 01:40:03 -0800351 struct pnp_option *option)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352{
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700353 struct pnp_port *port;
Bjorn Helgaas07d4e9a2007-07-26 10:41:21 -0700354
Robert P. J. Daycd861282006-12-13 00:34:52 -0800355 port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 if (!port)
357 return;
358 port->min = (p[3] << 8) | p[2];
359 port->max = (p[5] << 8) | p[4];
360 port->align = p[6];
361 port->size = p[7];
362 port->flags = p[1] ? PNP_PORT_FLAG_16BITADDR : 0;
Bjorn Helgaasc1caf062008-04-28 16:34:04 -0600363 pnp_register_port_resource(dev, option, port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364}
365
Bjorn Helgaasc1caf062008-04-28 16:34:04 -0600366static __init void pnpbios_parse_fixed_port_option(struct pnp_dev *dev,
367 unsigned char *p, int size,
Thomas Renninger2bb9a6b2008-02-06 01:40:03 -0800368 struct pnp_option *option)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369{
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700370 struct pnp_port *port;
Bjorn Helgaas07d4e9a2007-07-26 10:41:21 -0700371
Robert P. J. Daycd861282006-12-13 00:34:52 -0800372 port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 if (!port)
374 return;
375 port->min = port->max = (p[2] << 8) | p[1];
376 port->size = p[3];
377 port->align = 0;
378 port->flags = PNP_PORT_FLAG_FIXED;
Bjorn Helgaasc1caf062008-04-28 16:34:04 -0600379 pnp_register_port_resource(dev, option, port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380}
381
Thomas Renninger2bb9a6b2008-02-06 01:40:03 -0800382static __init unsigned char *
383pnpbios_parse_resource_option_data(unsigned char *p, unsigned char *end,
384 struct pnp_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385{
386 unsigned int len, tag;
387 int priority = 0;
388 struct pnp_option *option, *option_independent;
389
390 if (!p)
391 return NULL;
392
393 option_independent = option = pnp_register_independent_option(dev);
394 if (!option)
395 return NULL;
396
397 while ((char *)p < (char *)end) {
398
399 /* determine the type of tag */
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700400 if (p[0] & LARGE_TAG) { /* large tag */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 len = (p[2] << 8) | p[1];
402 tag = p[0];
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700403 } else { /* small tag */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 len = p[0] & 0x07;
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700405 tag = ((p[0] >> 3) & 0x0f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 }
407
408 switch (tag) {
409
410 case LARGE_TAG_MEM:
411 if (len != 9)
412 goto len_err;
Bjorn Helgaasc1caf062008-04-28 16:34:04 -0600413 pnpbios_parse_mem_option(dev, p, len, option);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 break;
415
416 case LARGE_TAG_MEM32:
417 if (len != 17)
418 goto len_err;
Bjorn Helgaasc1caf062008-04-28 16:34:04 -0600419 pnpbios_parse_mem32_option(dev, p, len, option);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 break;
421
422 case LARGE_TAG_FIXEDMEM32:
423 if (len != 9)
424 goto len_err;
Bjorn Helgaasc1caf062008-04-28 16:34:04 -0600425 pnpbios_parse_fixed_mem32_option(dev, p, len, option);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 break;
427
428 case SMALL_TAG_IRQ:
429 if (len < 2 || len > 3)
430 goto len_err;
Bjorn Helgaasc1caf062008-04-28 16:34:04 -0600431 pnpbios_parse_irq_option(dev, p, len, option);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 break;
433
434 case SMALL_TAG_DMA:
435 if (len != 2)
436 goto len_err;
Bjorn Helgaasc1caf062008-04-28 16:34:04 -0600437 pnpbios_parse_dma_option(dev, p, len, option);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 break;
439
440 case SMALL_TAG_PORT:
441 if (len != 7)
442 goto len_err;
Bjorn Helgaasc1caf062008-04-28 16:34:04 -0600443 pnpbios_parse_port_option(dev, p, len, option);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 break;
445
446 case SMALL_TAG_VENDOR:
447 /* do nothing */
448 break;
449
450 case SMALL_TAG_FIXEDPORT:
451 if (len != 3)
452 goto len_err;
Bjorn Helgaasc1caf062008-04-28 16:34:04 -0600453 pnpbios_parse_fixed_port_option(dev, p, len, option);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 break;
455
456 case SMALL_TAG_STARTDEP:
457 if (len > 1)
458 goto len_err;
459 priority = 0x100 | PNP_RES_PRIORITY_ACCEPTABLE;
460 if (len > 0)
461 priority = 0x100 | p[1];
462 option = pnp_register_dependent_option(dev, priority);
463 if (!option)
464 return NULL;
465 break;
466
467 case SMALL_TAG_ENDDEP:
468 if (len != 0)
469 goto len_err;
470 if (option_independent == option)
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700471 printk(KERN_WARNING
472 "PnPBIOS: Missing SMALL_TAG_STARTDEP tag\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 option = option_independent;
Bjorn Helgaasc1caf062008-04-28 16:34:04 -0600474 dev_dbg(&dev->dev, "end dependent options\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 break;
476
477 case SMALL_TAG_END:
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700478 return p + 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700480 default: /* an unkown tag */
Bjorn Helgaas1e0aa9a2007-08-15 10:32:08 -0600481len_err:
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700482 printk(KERN_ERR
483 "PnPBIOS: Unknown tag '0x%x', length '%d'.\n",
484 tag, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 break;
486 }
487
488 /* continue to the next tag */
489 if (p[0] & LARGE_TAG)
490 p += len + 3;
491 else
492 p += len + 1;
493 }
494
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700495 printk(KERN_ERR
496 "PnPBIOS: Resource structure does not contain an end tag.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497
498 return NULL;
499}
500
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501/*
502 * Compatible Device IDs
503 */
504
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700505static unsigned char *pnpbios_parse_compatible_ids(unsigned char *p,
506 unsigned char *end,
507 struct pnp_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508{
509 int len, tag;
Bjorn Helgaas25eb8462008-04-28 16:33:53 -0600510 u32 eisa_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 char id[8];
512 struct pnp_id *dev_id;
513
514 if (!p)
515 return NULL;
516
517 while ((char *)p < (char *)end) {
518
519 /* determine the type of tag */
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700520 if (p[0] & LARGE_TAG) { /* large tag */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 len = (p[2] << 8) | p[1];
522 tag = p[0];
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700523 } else { /* small tag */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 len = p[0] & 0x07;
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700525 tag = ((p[0] >> 3) & 0x0f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 }
527
528 switch (tag) {
529
530 case LARGE_TAG_ANSISTR:
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700531 strncpy(dev->name, p + 3,
532 len >= PNP_NAME_LEN ? PNP_NAME_LEN - 2 : len);
533 dev->name[len >=
534 PNP_NAME_LEN ? PNP_NAME_LEN - 1 : len] = '\0';
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 break;
536
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700537 case SMALL_TAG_COMPATDEVID: /* compatible ID */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 if (len != 4)
539 goto len_err;
Bjorn Helgaas25eb8462008-04-28 16:33:53 -0600540 eisa_id = p[1] | p[2] << 8 | p[3] << 16 | p[4] << 24;
541 pnp_eisa_id_to_string(eisa_id & PNP_EISA_ID_MASK, id);
Bjorn Helgaas772defc2008-04-28 16:33:52 -0600542 dev_id = pnp_add_id(dev, id);
543 if (!dev_id)
544 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 break;
546
547 case SMALL_TAG_END:
548 p = p + 2;
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700549 return (unsigned char *)p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 break;
551
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700552 default: /* an unkown tag */
Bjorn Helgaas1e0aa9a2007-08-15 10:32:08 -0600553len_err:
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700554 printk(KERN_ERR
555 "PnPBIOS: Unknown tag '0x%x', length '%d'.\n",
556 tag, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 break;
558 }
559
560 /* continue to the next tag */
561 if (p[0] & LARGE_TAG)
562 p += len + 3;
563 else
564 p += len + 1;
565 }
566
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700567 printk(KERN_ERR
568 "PnPBIOS: Resource structure does not contain an end tag.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
570 return NULL;
571}
572
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573/*
574 * Allocated Resource Encoding
575 */
576
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700577static void pnpbios_encode_mem(unsigned char *p, struct resource *res)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578{
579 unsigned long base = res->start;
580 unsigned long len = res->end - res->start + 1;
Bjorn Helgaas07d4e9a2007-07-26 10:41:21 -0700581
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 p[4] = (base >> 8) & 0xff;
583 p[5] = ((base >> 8) >> 8) & 0xff;
584 p[6] = (base >> 8) & 0xff;
585 p[7] = ((base >> 8) >> 8) & 0xff;
586 p[10] = (len >> 8) & 0xff;
587 p[11] = ((len >> 8) >> 8) & 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588}
589
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700590static void pnpbios_encode_mem32(unsigned char *p, struct resource *res)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591{
592 unsigned long base = res->start;
593 unsigned long len = res->end - res->start + 1;
Bjorn Helgaas07d4e9a2007-07-26 10:41:21 -0700594
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 p[4] = base & 0xff;
596 p[5] = (base >> 8) & 0xff;
597 p[6] = (base >> 16) & 0xff;
598 p[7] = (base >> 24) & 0xff;
599 p[8] = base & 0xff;
600 p[9] = (base >> 8) & 0xff;
601 p[10] = (base >> 16) & 0xff;
602 p[11] = (base >> 24) & 0xff;
603 p[16] = len & 0xff;
604 p[17] = (len >> 8) & 0xff;
605 p[18] = (len >> 16) & 0xff;
606 p[19] = (len >> 24) & 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607}
608
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700609static void pnpbios_encode_fixed_mem32(unsigned char *p, struct resource *res)
610{
611 unsigned long base = res->start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 unsigned long len = res->end - res->start + 1;
Bjorn Helgaas07d4e9a2007-07-26 10:41:21 -0700613
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 p[4] = base & 0xff;
615 p[5] = (base >> 8) & 0xff;
616 p[6] = (base >> 16) & 0xff;
617 p[7] = (base >> 24) & 0xff;
618 p[8] = len & 0xff;
619 p[9] = (len >> 8) & 0xff;
620 p[10] = (len >> 16) & 0xff;
621 p[11] = (len >> 24) & 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622}
623
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700624static void pnpbios_encode_irq(unsigned char *p, struct resource *res)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625{
626 unsigned long map = 0;
Bjorn Helgaas07d4e9a2007-07-26 10:41:21 -0700627
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 map = 1 << res->start;
629 p[1] = map & 0xff;
630 p[2] = (map >> 8) & 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631}
632
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700633static void pnpbios_encode_dma(unsigned char *p, struct resource *res)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634{
635 unsigned long map = 0;
Bjorn Helgaas07d4e9a2007-07-26 10:41:21 -0700636
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 map = 1 << res->start;
638 p[1] = map & 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639}
640
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700641static void pnpbios_encode_port(unsigned char *p, struct resource *res)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642{
643 unsigned long base = res->start;
644 unsigned long len = res->end - res->start + 1;
Bjorn Helgaas07d4e9a2007-07-26 10:41:21 -0700645
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 p[2] = base & 0xff;
647 p[3] = (base >> 8) & 0xff;
648 p[4] = base & 0xff;
649 p[5] = (base >> 8) & 0xff;
650 p[7] = len & 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651}
652
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700653static void pnpbios_encode_fixed_port(unsigned char *p, struct resource *res)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654{
655 unsigned long base = res->start;
656 unsigned long len = res->end - res->start + 1;
Bjorn Helgaas07d4e9a2007-07-26 10:41:21 -0700657
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 p[1] = base & 0xff;
659 p[2] = (base >> 8) & 0xff;
660 p[3] = len & 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661}
662
Bjorn Helgaas4ab55d82008-04-28 16:34:06 -0600663static unsigned char *pnpbios_encode_allocated_resource_data(struct pnp_dev
664 *dev,
665 unsigned char *p,
666 unsigned char *end)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667{
Bjorn Helgaas4ab55d82008-04-28 16:34:06 -0600668 struct pnp_resource_table *res = &dev->res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 unsigned int len, tag;
670 int port = 0, irq = 0, dma = 0, mem = 0;
671
672 if (!p)
673 return NULL;
674
675 while ((char *)p < (char *)end) {
676
677 /* determine the type of tag */
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700678 if (p[0] & LARGE_TAG) { /* large tag */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 len = (p[2] << 8) | p[1];
680 tag = p[0];
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700681 } else { /* small tag */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 len = p[0] & 0x07;
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700683 tag = ((p[0] >> 3) & 0x0f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 }
685
686 switch (tag) {
687
688 case LARGE_TAG_MEM:
689 if (len != 9)
690 goto len_err;
691 pnpbios_encode_mem(p, &res->mem_resource[mem]);
692 mem++;
693 break;
694
695 case LARGE_TAG_MEM32:
696 if (len != 17)
697 goto len_err;
698 pnpbios_encode_mem32(p, &res->mem_resource[mem]);
699 mem++;
700 break;
701
702 case LARGE_TAG_FIXEDMEM32:
703 if (len != 9)
704 goto len_err;
705 pnpbios_encode_fixed_mem32(p, &res->mem_resource[mem]);
706 mem++;
707 break;
708
709 case SMALL_TAG_IRQ:
710 if (len < 2 || len > 3)
711 goto len_err;
712 pnpbios_encode_irq(p, &res->irq_resource[irq]);
713 irq++;
714 break;
715
716 case SMALL_TAG_DMA:
717 if (len != 2)
718 goto len_err;
719 pnpbios_encode_dma(p, &res->dma_resource[dma]);
720 dma++;
721 break;
722
723 case SMALL_TAG_PORT:
724 if (len != 7)
725 goto len_err;
726 pnpbios_encode_port(p, &res->port_resource[port]);
727 port++;
728 break;
729
730 case SMALL_TAG_VENDOR:
731 /* do nothing */
732 break;
733
734 case SMALL_TAG_FIXEDPORT:
735 if (len != 3)
736 goto len_err;
737 pnpbios_encode_fixed_port(p, &res->port_resource[port]);
738 port++;
739 break;
740
741 case SMALL_TAG_END:
742 p = p + 2;
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700743 return (unsigned char *)p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 break;
745
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700746 default: /* an unkown tag */
Bjorn Helgaas1e0aa9a2007-08-15 10:32:08 -0600747len_err:
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700748 printk(KERN_ERR
749 "PnPBIOS: Unknown tag '0x%x', length '%d'.\n",
750 tag, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 break;
752 }
753
754 /* continue to the next tag */
755 if (p[0] & LARGE_TAG)
756 p += len + 3;
757 else
758 p += len + 1;
759 }
760
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700761 printk(KERN_ERR
762 "PnPBIOS: Resource structure does not contain an end tag.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763
764 return NULL;
765}
766
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767/*
768 * Core Parsing Functions
769 */
770
Thomas Renninger2bb9a6b2008-02-06 01:40:03 -0800771int __init pnpbios_parse_data_stream(struct pnp_dev *dev,
772 struct pnp_bios_node *node)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773{
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700774 unsigned char *p = (char *)node->data;
775 unsigned char *end = (char *)(node->data + node->size);
Bjorn Helgaas07d4e9a2007-07-26 10:41:21 -0700776
Bjorn Helgaas4ab55d82008-04-28 16:34:06 -0600777 p = pnpbios_parse_allocated_resource_data(dev, p, end);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 if (!p)
779 return -EIO;
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700780 p = pnpbios_parse_resource_option_data(p, end, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 if (!p)
782 return -EIO;
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700783 p = pnpbios_parse_compatible_ids(p, end, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 if (!p)
785 return -EIO;
786 return 0;
787}
788
Bjorn Helgaas4ab55d82008-04-28 16:34:06 -0600789int pnpbios_read_resources_from_node(struct pnp_dev *dev,
Bjorn Helgaas07d4e9a2007-07-26 10:41:21 -0700790 struct pnp_bios_node *node)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791{
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700792 unsigned char *p = (char *)node->data;
793 unsigned char *end = (char *)(node->data + node->size);
Bjorn Helgaas07d4e9a2007-07-26 10:41:21 -0700794
Bjorn Helgaas4ab55d82008-04-28 16:34:06 -0600795 p = pnpbios_parse_allocated_resource_data(dev, p, end);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 if (!p)
797 return -EIO;
798 return 0;
799}
800
Bjorn Helgaas4ab55d82008-04-28 16:34:06 -0600801int pnpbios_write_resources_to_node(struct pnp_dev *dev,
Bjorn Helgaas07d4e9a2007-07-26 10:41:21 -0700802 struct pnp_bios_node *node)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803{
Bjorn Helgaas9dd78462007-07-26 10:41:20 -0700804 unsigned char *p = (char *)node->data;
805 unsigned char *end = (char *)(node->data + node->size);
Bjorn Helgaas07d4e9a2007-07-26 10:41:21 -0700806
Bjorn Helgaas4ab55d82008-04-28 16:34:06 -0600807 p = pnpbios_encode_allocated_resource_data(dev, p, end);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 if (!p)
809 return -EIO;
810 return 0;
811}