sys/dev/acpica/acpi_quirk.c

   1 /*-
   2  * Copyright (c) 2004 Nate Lawson (SDG)
   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: head/sys/dev/acpica/acpi_quirk.c 193530 2009-06-05 18:44:36Z jkim $
  27  */
  28
  29 #include <sys/param.h>
  30 #include <sys/bus.h>
  31
  32 #include <contrib/dev/acpica/source/include/acpi.h>
  33
  34 #include <dev/acpica/acpivar.h>
  35
  36 enum ops_t {
  37         OP_NONE,
  38         OP_LEQ,
  39         OP_GEQ,
  40         OP_EQL,
  41 };
  42
  43 enum val_t {
  44         OEM,
  45         OEM_REV,
  46         CREATOR,
  47         CREATOR_REV,
  48 };
  49
  50 struct acpi_q_rule {
  51     char        sig[ACPI_NAME_SIZE];    /* Table signature to match */
  52     enum val_t  val;
  53     union {
  54         char    *id;
  55         enum ops_t op;
  56     } x;
  57     union {
  58         char    *tid;
  59         int     rev;
  60     } y;
  61 };
  62
  63 struct acpi_q_entry {
  64     const struct acpi_q_rule *match;
  65     int         quirks;
  66 };
  67
  68 #include "acpi_quirks.h"
  69
  70 static int      aq_revcmp(int revision, enum ops_t op, int value);
  71 static int      aq_strcmp(char *actual, char *possible);
  72 static int      aq_match_header(ACPI_TABLE_HEADER *hdr,
  73                     const struct acpi_q_rule *match);
  74
  75 static int
  76 aq_revcmp(int revision, enum ops_t op, int value)
  77 {
  78     switch (op) {
  79     case OP_LEQ:
  80         if (revision <= value)
  81             return (TRUE);
  82         break;
  83     case OP_GEQ:
  84         if (revision >= value)
  85             return (TRUE);
  86         break;
  87     case OP_EQL:
  88         if (revision == value)
  89             return (TRUE);
  90         break;
  91     case OP_NONE:
  92         return (TRUE);
  93     default:
  94         panic("aq_revcmp: invalid op %d", op);
  95     }
  96
  97     return (FALSE);
  98 }
  99
 100 static int
 101 aq_strcmp(char *actual, char *possible)
 102 {
 103     if (actual == NULL || possible == NULL)
 104         return (TRUE);
 105     return (strncmp(actual, possible, strlen(possible)) == 0);
 106 }
 107
 108 static int
 109 aq_match_header(ACPI_TABLE_HEADER *hdr, const struct acpi_q_rule *match)
 110 {
 111     int result;
 112
 113     result = FALSE;
 114     switch (match->val) {
 115     case OEM:
 116         if (aq_strcmp(hdr->OemId, match->x.id) &&
 117             aq_strcmp(hdr->OemTableId, match->y.tid))
 118             result = TRUE;
 119         break;
 120     case CREATOR:
 121         if (aq_strcmp(hdr->AslCompilerId, match->x.id))
 122             result = TRUE;
 123         break;
 124     case OEM_REV:
 125         if (aq_revcmp(hdr->OemRevision, match->x.op, match->y.rev))
 126             result = TRUE;
 127         break;
 128     case CREATOR_REV:
 129         if (aq_revcmp(hdr->AslCompilerRevision, match->x.op, match->y.rev))
 130             result = TRUE;
 131         break;
 132     }
 133
 134     return (result);
 135 }
 136
 137 int
 138 acpi_table_quirks(int *quirks)
 139 {
 140     const struct acpi_q_entry *entry;
 141     const struct acpi_q_rule *match;
 142     ACPI_TABLE_HEADER fadt, dsdt, xsdt, *hdr;
 143     int done;
 144
 145     /* First, allow the machdep system to set its idea of quirks. */
 146     KASSERT(quirks != NULL, ("acpi quirks ptr is NULL"));
 147     acpi_machdep_quirks(quirks);
 148
 149     if (ACPI_FAILURE(AcpiGetTableHeader(ACPI_SIG_FADT, 0, &fadt)))
 150         bzero(&fadt, sizeof(fadt));
 151     if (ACPI_FAILURE(AcpiGetTableHeader(ACPI_SIG_DSDT, 0, &dsdt)))
 152         bzero(&dsdt, sizeof(dsdt));
 153     if (ACPI_FAILURE(AcpiGetTableHeader(ACPI_SIG_XSDT, 0, &xsdt)))
 154         bzero(&xsdt, sizeof(xsdt));
 155
 156     /* Then, override the quirks with any matched from table signatures. */
 157     for (entry = acpi_quirks_table; entry->match; entry++) {
 158         done = TRUE;
 159         for (match = entry->match; match->sig[0] != '\0'; match++) {
 160             if (ACPI_COMPARE_NAME(match->sig, "FADT"))
 161                 hdr = &fadt;
 162             else if (ACPI_COMPARE_NAME(match->sig, ACPI_SIG_DSDT))
 163                 hdr = &dsdt;
 164             else if (ACPI_COMPARE_NAME(match->sig, ACPI_SIG_XSDT))
 165                 hdr = &xsdt;
 166             else
 167                 panic("invalid quirk header\n");
 168
 169             /* If we don't match any, skip to the next entry. */
 170             if (aq_match_header(hdr, match) == FALSE) {
 171                 done = FALSE;
 172                 break;
 173             }
 174         }
 175
 176         /* If all entries matched, update the quirks and return. */
 177         if (done) {
 178             *quirks = entry->quirks;
 179             break;
 180         }
 181     }
 182
 183     return (0);
 184 }