PCI compat cleanup, part 1. This brings in the LNC and VX drivers
[dragonfly.git] / sys / bus / isa / pnpparse.c
1 /*-
2  * Copyright (c) 1999 Doug Rabson
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  * $FreeBSD: src/sys/isa/pnpparse.c,v 1.14 2003/06/11 00:32:45 obrien Exp $
27  * $DragonFly: src/sys/bus/isa/pnpparse.c,v 1.5 2003/11/09 02:22:33 dillon Exp $
28  */
29
30 #include <sys/param.h>
31 #include <sys/systm.h>
32 #include <sys/malloc.h>
33 #include <sys/module.h>
34 #include <sys/bus.h>
35
36 #include <machine/stdarg.h>
37
38 #include "isavar.h"
39 #include "pnpreg.h"
40 #include "pnpvar.h"
41
42 #define MAXDEP  8
43
44 #define I16(p)  ((p)[0] + ((p)[1] << 8))
45 #define I32(p)  (I16(p) + (I16((p)+2) << 16))
46
47 void
48 pnp_printf(u_int32_t id, char *fmt, ...)
49 {
50         __va_list ap;
51
52         __va_start(ap, fmt);
53         printf("%s: ", pnp_eisaformat(id));
54         vprintf(fmt, ap);
55         __va_end(ap);
56 }
57
58 /* parse a single descriptor */
59
60 static int
61 pnp_parse_desc(device_t dev, u_char tag, u_char *res, int len,
62                struct isa_config *config, int ldn)
63 {
64         char buf[100];
65         u_int32_t id;
66         u_int32_t compat_id;
67         int temp;
68
69         id = isa_get_logicalid(dev);
70
71         if (PNP_RES_TYPE(tag) == 0) {
72
73                 /* Small resource */
74                 switch (PNP_SRES_NUM(tag)) {
75
76                 case PNP_TAG_VERSION:
77                 case PNP_TAG_VENDOR:
78                         /* these descriptors are quietly ignored */
79                         break;
80
81                 case PNP_TAG_LOGICAL_DEVICE:
82                 case PNP_TAG_START_DEPENDANT:
83                 case PNP_TAG_END_DEPENDANT:
84                         if (bootverbose)
85                                 pnp_printf(id, "unexpected small tag %d\n",
86                                            PNP_SRES_NUM(tag));
87                         /* shouldn't happen; quit now */
88                         return (1);
89
90                 case PNP_TAG_COMPAT_DEVICE:
91                         /*
92                          * Got a compatible device id resource.
93                          * Should keep a list of compat ids in the device.
94                          */
95                         bcopy(res, &compat_id, 4);
96                         if (isa_get_compatid(dev) == 0)
97                                 isa_set_compatid(dev, compat_id);
98                         break;
99             
100                 case PNP_TAG_IRQ_FORMAT:
101                         if (config->ic_nirq == ISA_NIRQ) {
102                                 pnp_printf(id, "too many irqs\n");
103                                 return (1);
104                         }
105                         if (I16(res) == 0) {
106                                 /* a null descriptor */
107                                 config->ic_irqmask[config->ic_nirq] = 0;
108                                 config->ic_nirq++;
109                                 break;
110                         }
111                         if (bootverbose)
112                                 pnp_printf(id, "adding irq mask %#02x\n",
113                                            I16(res));
114                         config->ic_irqmask[config->ic_nirq] = I16(res);
115                         config->ic_nirq++;
116                         break;
117
118                 case PNP_TAG_DMA_FORMAT:
119                         if (config->ic_ndrq == ISA_NDRQ) {
120                                 pnp_printf(id, "too many drqs\n");
121                                 return (1);
122                         }
123                         if (res[0] == 0) {
124                                 /* a null descriptor */
125                                 config->ic_drqmask[config->ic_ndrq] = 0;
126                                 config->ic_ndrq++;
127                                 break;
128                         }
129                         if (bootverbose)
130                                 pnp_printf(id, "adding dma mask %#02x\n",
131                                            res[0]);
132                         config->ic_drqmask[config->ic_ndrq] = res[0];
133                         config->ic_ndrq++;
134                         break;
135
136                 case PNP_TAG_IO_RANGE:
137                         if (config->ic_nport == ISA_NPORT) {
138                                 pnp_printf(id, "too many ports\n");
139                                 return (1);
140                         }
141                         if (res[6] == 0) {
142                                 /* a null descriptor */
143                                 config->ic_port[config->ic_nport].ir_start = 0;
144                                 config->ic_port[config->ic_nport].ir_end = 0;
145                                 config->ic_port[config->ic_nport].ir_size = 0;
146                                 config->ic_port[config->ic_nport].ir_align = 0;
147                                 config->ic_nport++;
148                                 break;
149                         }
150                         if (bootverbose) {
151                                 pnp_printf(id, "adding io range "
152                                            "%#x-%#x, size=%#x, "
153                                            "align=%#x\n",
154                                            I16(res + 1),
155                                            I16(res + 3) + res[6]-1,
156                                            res[6], res[5]);
157                         }
158                         config->ic_port[config->ic_nport].ir_start =
159                             I16(res + 1);
160                         config->ic_port[config->ic_nport].ir_end =
161                             I16(res + 3) + res[6] - 1;
162                         config->ic_port[config->ic_nport].ir_size = res[6];
163                         if (res[5] == 0) {
164                             /* Make sure align is at least one */
165                             res[5] = 1;
166                         }
167                         config->ic_port[config->ic_nport].ir_align = res[5];
168                         config->ic_nport++;
169                         pnp_check_quirks(isa_get_vendorid(dev),
170                                          isa_get_logicalid(dev), ldn, config);
171                         break;
172
173                 case PNP_TAG_IO_FIXED:
174                         if (config->ic_nport == ISA_NPORT) {
175                                 pnp_printf(id, "too many ports\n");
176                                 return (1);
177                         }
178                         if (res[2] == 0) {
179                                 /* a null descriptor */
180                                 config->ic_port[config->ic_nport].ir_start = 0;
181                                 config->ic_port[config->ic_nport].ir_end = 0;
182                                 config->ic_port[config->ic_nport].ir_size = 0;
183                                 config->ic_port[config->ic_nport].ir_align = 0;
184                                 config->ic_nport++;
185                                 break;
186                         }
187                         if (bootverbose) {
188                                 pnp_printf(id, "adding fixed io range "
189                                            "%#x-%#x, size=%#x, "
190                                            "align=%#x\n",
191                                            I16(res),
192                                            I16(res) + res[2] - 1,
193                                            res[2], 1);
194                         }
195                         config->ic_port[config->ic_nport].ir_start = I16(res);
196                         config->ic_port[config->ic_nport].ir_end =
197                             I16(res) + res[2] - 1;
198                         config->ic_port[config->ic_nport].ir_size = res[2];
199                         config->ic_port[config->ic_nport].ir_align = 1;
200                         config->ic_nport++;
201                         break;
202
203                 case PNP_TAG_END:
204                         if (bootverbose)
205                                 pnp_printf(id, "end config\n");
206                         return (1);
207
208                 default:
209                         /* Skip this resource */
210                         pnp_printf(id, "unexpected small tag %d\n",
211                                       PNP_SRES_NUM(tag));
212                         break;
213                 }
214         } else {
215                 /* Large resource */
216                 switch (PNP_LRES_NUM(tag)) {
217
218                 case PNP_TAG_ID_UNICODE:
219                 case PNP_TAG_LARGE_VENDOR:
220                         /* these descriptors are quietly ignored */
221                         break;
222
223                 case PNP_TAG_ID_ANSI:
224                         if (len > sizeof(buf) - 1)
225                                 len = sizeof(buf) - 1;
226                         bcopy(res, buf, len);
227
228                         /*
229                          * Trim trailing spaces and garbage.
230                          */
231                         while (len > 0 && buf[len - 1] <= ' ')
232                                 len--;
233                         buf[len] = '\0';
234                         device_set_desc_copy(dev, buf);
235                         break;
236                         
237                 case PNP_TAG_MEMORY_RANGE:
238                         if (config->ic_nmem == ISA_NMEM) {
239                                 pnp_printf(id, "too many memory ranges\n");
240                                 return (1);
241                         }
242                         if (I16(res + 7) == 0) {
243                                 /* a null descriptor */
244                                 config->ic_mem[config->ic_nmem].ir_start = 0;
245                                 config->ic_mem[config->ic_nmem].ir_end = 0;
246                                 config->ic_mem[config->ic_nmem].ir_size = 0;
247                                 config->ic_mem[config->ic_nmem].ir_align = 0;
248                                 config->ic_nmem++;
249                                 break;
250                         }
251                         if (bootverbose) {
252                                 temp = I16(res + 7) << 8;
253                                 pnp_printf(id, "adding memory range "
254                                            "%#x-%#x, size=%#x, "
255                                            "align=%#x\n",
256                                            I16(res + 1) << 8,
257                                            (I16(res + 3) << 8) + temp - 1,
258                                            temp, I16(res + 5));
259                         }
260                         config->ic_mem[config->ic_nmem].ir_start =
261                             I16(res + 1) << 8;
262                         config->ic_mem[config->ic_nmem].ir_end =
263                             (I16(res + 3) << 8) + (I16(res + 7) << 8) - 1;
264                         config->ic_mem[config->ic_nmem].ir_size =
265                             I16(res + 7) << 8;
266                         config->ic_mem[config->ic_nmem].ir_align = I16(res + 5);
267                         if (!config->ic_mem[config->ic_nmem].ir_align)
268                                 config->ic_mem[config->ic_nmem].ir_align =
269                                     0x10000;
270                         config->ic_nmem++;
271                         break;
272
273                 case PNP_TAG_MEMORY32_RANGE:
274                         if (config->ic_nmem == ISA_NMEM) {
275                                 pnp_printf(id, "too many memory ranges\n");
276                                 return (1);
277                         }
278                         if (I32(res + 13) == 0) {
279                                 /* a null descriptor */
280                                 config->ic_mem[config->ic_nmem].ir_start = 0;
281                                 config->ic_mem[config->ic_nmem].ir_end = 0;
282                                 config->ic_mem[config->ic_nmem].ir_size = 0;
283                                 config->ic_mem[config->ic_nmem].ir_align = 0;
284                                 config->ic_nmem++;
285                                 break;
286                         }
287                         if (bootverbose) {
288                                 pnp_printf(id, "adding memory32 range "
289                                            "%#x-%#x, size=%#x, "
290                                            "align=%#x\n",
291                                            I32(res + 1),
292                                            I32(res + 5) + I32(res + 13) - 1,
293                                            I32(res + 13), I32(res + 9));
294                         }
295                         config->ic_mem[config->ic_nmem].ir_start = I32(res + 1);
296                         config->ic_mem[config->ic_nmem].ir_end =
297                             I32(res + 5) + I32(res + 13) - 1;
298                         config->ic_mem[config->ic_nmem].ir_size = I32(res + 13);
299                         config->ic_mem[config->ic_nmem].ir_align = I32(res + 9);
300                         config->ic_nmem++;
301                         break;
302
303                 case PNP_TAG_MEMORY32_FIXED:
304                         if (config->ic_nmem == ISA_NMEM) {
305                                 pnp_printf(id, "too many memory ranges\n");
306                                 return (1);
307                         }
308                         if (I32(res + 5) == 0) {
309                                 /* a null descriptor */
310                                 config->ic_mem[config->ic_nmem].ir_start = 0;
311                                 config->ic_mem[config->ic_nmem].ir_end = 0;
312                                 config->ic_mem[config->ic_nmem].ir_size = 0;
313                                 config->ic_mem[config->ic_nmem].ir_align = 0;
314                                 break;
315                         }
316                         if (bootverbose) {
317                                 pnp_printf(id, "adding fixed memory32 range "
318                                            "%#x-%#x, size=%#x\n",
319                                            I32(res + 1),
320                                            I32(res + 1) + I32(res + 5) - 1,
321                                            I32(res + 5));
322                         }
323                         config->ic_mem[config->ic_nmem].ir_start = I32(res + 1);
324                         config->ic_mem[config->ic_nmem].ir_end =
325                             I32(res + 1) + I32(res + 5) - 1;
326                         config->ic_mem[config->ic_nmem].ir_size = I32(res + 5);
327                         config->ic_mem[config->ic_nmem].ir_align = 1;
328                         config->ic_nmem++;
329                         break;
330
331                 default:
332                         /* Skip this resource */
333                         pnp_printf(id, "unexpected large tag %d\n",
334                                    PNP_SRES_NUM(tag));
335                         break;
336                 }
337         }
338
339         return (0);
340 }
341
342 /*
343  * Parse a single "dependent" resource combination.
344  */
345
346 u_char *
347 pnp_parse_dependant(device_t dev, u_char *resources, int len,
348                      struct isa_config *config, int ldn)
349 {
350         u_char *res;
351
352         res = pnp_scan_resources(dev, resources, len, config,
353                                 ldn, pnp_parse_desc);
354         return(res);
355 }
356
357 static void
358 pnp_merge_resources(device_t dev, struct isa_config *from,
359                     struct isa_config *to)
360 {
361         device_t parent;
362         int i;
363
364         parent = device_get_parent(dev);
365         for (i = 0; i < from->ic_nmem; i++) {
366                 if (to->ic_nmem == ISA_NMEM) {
367                         device_printf(parent, "too many memory ranges\n");
368                         return;
369                 }
370                 to->ic_mem[to->ic_nmem] = from->ic_mem[i];
371                 to->ic_nmem++;
372         }
373         for (i = 0; i < from->ic_nport; i++) {
374                 if (to->ic_nport == ISA_NPORT) {
375                         device_printf(parent, "too many port ranges\n");
376                         return;
377                 }
378                 to->ic_port[to->ic_nport] = from->ic_port[i];
379                 to->ic_nport++;
380         }
381         for (i = 0; i < from->ic_nirq; i++) {
382                 if (to->ic_nirq == ISA_NIRQ) {
383                         device_printf(parent, "too many irq ranges\n");
384                         return;
385                 }
386                 to->ic_irqmask[to->ic_nirq] = from->ic_irqmask[i];
387                 to->ic_nirq++;
388         }
389         for (i = 0; i < from->ic_ndrq; i++) {
390                 if (to->ic_ndrq == ISA_NDRQ) {
391                         device_printf(parent, "too many drq ranges\n");
392                         return;
393                 }
394                 to->ic_drqmask[to->ic_ndrq] = from->ic_drqmask[i];
395                 to->ic_ndrq++;
396         }
397 }
398
399 /*
400  * Parse resource data for Logical Devices, make a list of available
401  * resource configurations, and add them to the device.
402  *
403  * This function exits as soon as it gets an error reading *ANY*
404  * Resource Data or it reaches the end of Resource Data.
405  */
406
407 void
408 pnp_parse_resources(device_t dev, u_char *resources, int len, int ldn)
409 {
410         struct isa_config *configs;
411         struct isa_config *config;
412         device_t parent;
413         int priorities[1 + MAXDEP];
414         u_char *start;
415         u_char *p;
416         u_char tag;
417         u_int32_t id;
418         int ncfgs;
419         int l;
420         int i;
421
422         parent = device_get_parent(dev);
423         id = isa_get_logicalid(dev);
424
425         configs = (struct isa_config *)malloc(sizeof(*configs)*(1 + MAXDEP),
426                                               M_DEVBUF, M_NOWAIT | M_ZERO);
427         if (configs == NULL) {
428                 device_printf(parent, "No memory to parse PNP data\n");
429                 return;
430         }
431         config = &configs[0];
432         priorities[0] = 0;
433         ncfgs = 1;
434
435         p = resources;
436         start = NULL;
437         while (len > 0) {
438                 tag = *p++;
439                 len--;
440                 if (PNP_RES_TYPE(tag) == 0) {
441                         /* Small resource */
442                         l = PNP_SRES_LEN(tag);
443                         if (len < l) {
444                                 len = 0;
445                                 continue;
446                         }
447                         len -= l;
448
449                         switch (PNP_SRES_NUM(tag)) {
450
451                         case PNP_TAG_START_DEPENDANT:
452                                 if (start != NULL) {
453                                         /*
454                                          * Copy the common resources first,
455                                          * then parse the "dependent" resources.
456                                          */
457                                         pnp_merge_resources(dev, &configs[0],
458                                                             config);
459                                         pnp_parse_dependant(dev, start,
460                                                             p - start - 1,
461                                                             config, ldn);
462                                 }
463                                 start = p + l;
464                                 if (ncfgs > MAXDEP) {
465                                         device_printf(parent, "too many dependant configs (%d)\n", MAXDEP);
466                                         len = 0;
467                                         break;
468                                 }
469                                 config = &configs[ncfgs];
470                                 /*
471                                  * If the priority is not specified,
472                                  * then use the default of 'acceptable'
473                                  */
474                                 if (l > 0)
475                                         priorities[ncfgs] = p[0];
476                                 else
477                                         priorities[ncfgs] = 1;
478                                 if (bootverbose)
479                                         pnp_printf(id, "start dependent (%d)\n",
480                                                    priorities[ncfgs]);
481                                 ncfgs++;
482                                 break;
483
484                         case PNP_TAG_END_DEPENDANT:
485                                 if (start == NULL) {
486                                         device_printf(parent,
487                                                       "malformed resources\n");
488                                         len = 0;
489                                         break;
490                                 }
491                                 /*
492                                  * Copy the common resources first,
493                                  * then parse the "dependent" resources.
494                                  */
495                                 pnp_merge_resources(dev, &configs[0], config);
496                                 pnp_parse_dependant(dev, start, p - start - 1,
497                                                     config, ldn);
498                                 start = NULL;
499                                 if (bootverbose)
500                                         pnp_printf(id, "end dependent\n");
501                                 /*
502                                  * Back to the common part; clear it
503                                  * as its contents has already been copied
504                                  * to each dependant.
505                                  */
506                                 config = &configs[0];
507                                 bzero(config, sizeof(*config));
508                                 break;
509
510                         case PNP_TAG_END:
511                                 if (start != NULL) {
512                                         device_printf(parent,
513                                                       "malformed resources\n");
514                                 }
515                                 len = 0;
516                                 break;
517
518                         default:
519                                 if (start != NULL)
520                                         /* defer parsing a dependent section */
521                                         break;
522                                 if (pnp_parse_desc(dev, tag, p, l, config, ldn))
523                                         len = 0;
524                                 break;
525                         }
526                         p += l;
527                 } else {
528                         /* Large resource */
529                         if (len < 2) {
530                                 len = 0;
531                                 break;
532                         }
533                         l = I16(p);
534                         p += 2;
535                         len -= 2;
536                         if (len < l) {
537                                 len = 0;
538                                 break;
539                         }
540                         len -= l;
541                         if (start == NULL &&
542                             pnp_parse_desc(dev, tag, p, l, config, ldn)) {
543                                 len = 0;
544                                 break;
545                         }
546                         p += l;
547                 }
548         }
549
550         if (ncfgs == 1) {
551                 /* Single config without dependants */
552                 ISA_ADD_CONFIG(parent, dev, priorities[0], &configs[0]);
553                 free(configs, M_DEVBUF);
554                 return;
555         }
556
557         for (i = 1; i < ncfgs; i++) {
558                 /*
559                  * Merge the remaining part of the common resources,
560                  * if any. Strictly speaking, there shouldn't be common/main
561                  * resources after the END_DEPENDENT tag.
562                  */
563                 pnp_merge_resources(dev, &configs[0], &configs[i]);
564                 ISA_ADD_CONFIG(parent, dev, priorities[i], &configs[i]);
565         }
566
567         free(configs, M_DEVBUF);
568 }
569
570 u_char *
571 pnp_scan_resources(device_t dev, u_char *resources, int len,
572                     struct isa_config *config, int ldn, pnp_scan_cb *cb)
573 {
574         u_char *p;
575         u_char tag;
576         int l;
577
578         p = resources;
579         while (len > 0) {
580                 tag = *p++;
581                 len--;
582                 if (PNP_RES_TYPE(tag) == 0) {
583                         /* small resource */
584                         l = PNP_SRES_LEN(tag);
585                         if (len < l)
586                                 break;
587                         if ((*cb)(dev, tag, p, l, config, ldn))
588                                 return (p + l);
589                         if (PNP_SRES_NUM(tag) == PNP_TAG_END)
590                                 return (p + l);
591                 } else {
592                         /* large resource */
593                         if (len < 2)
594                                 break;
595                         l = I16(p);
596                         p += 2;
597                         len -= 2;
598                         if (len < l)
599                                 break;
600                         if ((*cb)(dev, tag, p, l, config, ldn))
601                                 return (p + l);
602                 }
603                 p += l;
604                 len -= l;
605         }
606         return NULL;
607 }