OpenSolaris_b135/uts/intel/io/acpica/master_ops.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#include <sys/kobj.h>
#include <sys/kobj_lex.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/sunndi.h>
#include <sys/acpi/acpi.h>
#include <sys/acpica.h>
#define masterfile "/boot/solaris/devicedb/master"
/*
* Internal definitions
*/
typedef enum {
MF_UNEXPECTED = -1,
MF_IDENT,
MF_STRING,
MF_EOF,
MF_NEWLINE,
MF_EQUALS,
MF_BIT_OR
} mftoken_t;
typedef enum {
MF_INIT,
MF_DEVID,
MF_NAME,
MF_DEVTYPE,
MF_BUSTYPE,
MF_BEFNAME,
MF_DESCRIPTION,
MF_PROPNAME,
MF_PROPASSIGN,
MF_PROPVAL,
MF_VERSION_DONE,
MF_VALID_DONE,
MF_ERROR_DONE
} mfparse_t;
static master_rec_t *master_list = NULL;
device_id_t *
mf_alloc_device_id()
{
return ((device_id_t *)kmem_zalloc(sizeof (device_id_t), KM_SLEEP));
}
void
mf_free_device_id(device_id_t *d)
{
if (d->id != NULL)
strfree(d->id);
kmem_free(d, sizeof (device_id_t));
}
static property_t *
mf_alloc_property()
{
return ((property_t *)kmem_zalloc(sizeof (property_t), KM_SLEEP));
}
static void
mf_free_property(property_t *p)
{
if (p->name != NULL)
strfree(p->name);
if (p->value != NULL)
strfree(p->value);
kmem_free(p, sizeof (property_t));
}
static master_rec_t *
mf_alloc_master_rec()
{
return ((master_rec_t *)kmem_zalloc(sizeof (master_rec_t), KM_SLEEP));
}
static void
mf_free_master_rec(master_rec_t *m)
{
device_id_t *d;
property_t *p;
if (m->name != NULL)
strfree(m->name);
if (m->description != NULL)
strfree(m->description);
d = m->device_ids;
while (d != NULL) {
device_id_t *next;
next = d->next;
mf_free_device_id(d);
d = next;
}
p = m->properties;
while (p != NULL) {
property_t *next;
next = p->next;
mf_free_property(p);
p = next;
}
kmem_free(m, sizeof (master_rec_t));
}
void
free_master_data()
{
master_rec_t *m;
m = master_list;
while (m != NULL) {
master_rec_t *next;
next = m->next;
mf_free_master_rec(m);
m = next;
}
master_list = NULL;
}
/*
* Unfortunately, kobj_lex() is too sophisticated for our needs
*/
static mftoken_t
mf_lex(struct _buf *file, char *val, size_t size)
{
char *cp;
int ch, badquote;
size_t remain;
mftoken_t token = MF_UNEXPECTED;
if (size < 2)
return (token); /* MF_UNEXPECTED */
cp = val;
/* skip leading whitespace */
while ((ch = kobj_getc(file)) == ' ' || ch == '\t')
;
/* strip comments */
if (ch == '#') {
while ((ch = kobj_getc(file)) != '\n' && ch != '\r' &&
ch != -1)
;
}
remain = size - 1;
*cp++ = (char)ch;
switch (ch) {
case -1:
token = MF_EOF;
break;
case '\n':
case '\r':
token = MF_NEWLINE;
break;
case '=':
token = MF_EQUALS;
break;
case '|':
token = MF_BIT_OR;
break;
case '"':
remain++;
cp--;
badquote = 0;
while (!badquote && (ch = kobj_getc(file)) != '"') {
switch (ch) {
case '\n':
case -1:
remain = size - 1;
cp = val;
*cp++ = '\n';
badquote = 1;
/* since we consumed the newline/EOF */
(void) kobj_ungetc(file);
break;
default:
if (--remain == 0) {
token = MF_UNEXPECTED;
goto out;
}
*cp++ = (char)ch;
break;
}
}
token = MF_STRING;
break;
default:
do {
if (--remain == 0) {
token = MF_UNEXPECTED;
break;
}
token = MF_IDENT;
*cp++ = (char)(ch = kobj_getc(file));
/* if terminating character, break out */
if ((ch == -1) || (ch == ' ') || (ch == '\t') ||
(ch == '\n') || (ch == '\r') || (ch == '=') ||
(ch == '|')) {
(void) kobj_ungetc(file);
remain++;
cp--;
break;
}
if ((ch == '#') || (ch == '"'))
token = MF_UNEXPECTED;
} while (token != MF_UNEXPECTED);
break;
}
out:
*cp = '\0';
return (token);
}
static master_rec_t *
get_line(struct _buf *file)
{
master_rec_t *m = NULL;
device_id_t *d = NULL;
property_t *p = NULL;
mftoken_t token;
char tokval[MAXPATHLEN];
mfparse_t parse_state;
parse_state = MF_INIT;
token = mf_lex(file, tokval, sizeof (tokval));
while (token != MF_EOF) {
switch (parse_state) {
case MF_INIT:
m = mf_alloc_master_rec();
parse_state = MF_DEVID;
/*FALLTHROUGH*/
case MF_DEVID:
if (token == MF_IDENT) {
d = mf_alloc_device_id();
d->id = strdup(tokval);
d->next = m->device_ids;
m->device_ids = d;
parse_state = MF_NAME;
} else if (token != MF_NEWLINE)
parse_state = MF_ERROR_DONE;
break;
case MF_NAME:
if (token == MF_IDENT) {
m->name = strdup(tokval);
parse_state = MF_DEVTYPE;
} else if (token == MF_BIT_OR) {
parse_state = MF_DEVID;
} else
parse_state = MF_ERROR_DONE;
break;
case MF_DEVTYPE:
if (token == MF_IDENT) {
/* device_type not used */
parse_state = MF_BUSTYPE;
} else if (token == MF_NEWLINE) {
/* version line ignored */
parse_state = MF_VERSION_DONE;
} else
parse_state = MF_ERROR_DONE;
break;
case MF_BUSTYPE:
if (token == MF_IDENT) {
/* bus_type ignored */
parse_state = MF_BEFNAME;
} else
parse_state = MF_ERROR_DONE;
break;
case MF_BEFNAME:
if (token == MF_IDENT) {
/* realmode driver name ignored */
parse_state = MF_DESCRIPTION;
} else
parse_state = MF_ERROR_DONE;
break;
case MF_DESCRIPTION:
if (token == MF_STRING) {
m->description = strdup(tokval);
parse_state = MF_PROPNAME;
} else
parse_state = MF_ERROR_DONE;
break;
case MF_PROPNAME:
if (token == MF_IDENT) {
p = mf_alloc_property();
p->name = strdup(tokval);
parse_state = MF_PROPASSIGN;
} else if (token == MF_NEWLINE) {
parse_state = MF_VALID_DONE;
} else
parse_state = MF_ERROR_DONE;
break;
case MF_PROPASSIGN:
if (token == MF_EQUALS) {
parse_state = MF_PROPVAL;
} else
parse_state = MF_ERROR_DONE;
break;
case MF_PROPVAL:
if (token == MF_STRING || token == MF_IDENT) {
p->value = strdup(tokval);
p->next = m->properties;
/* delete properties which begin with '$' */
if (*p->name == '$') {
mf_free_property(p);
} else
m->properties = p;
p = NULL;
parse_state = MF_PROPNAME;
} else
parse_state = MF_ERROR_DONE;
break;
case MF_VERSION_DONE:
case MF_VALID_DONE:
case MF_ERROR_DONE:
/* terminating states handled outside switch() */
break;
}
if (parse_state == MF_VERSION_DONE) {
/* ignore version line */
mf_free_master_rec(m);
parse_state = MF_INIT;
} else if (parse_state == MF_VALID_DONE) {
/* valid line */
break;
} else if (parse_state == MF_ERROR_DONE) {
mf_free_master_rec(m);
if (p != NULL)
mf_free_property(p);
/*
* Error in master file. Should never happen
* since master file is not user-edited. Eat rest
* of line to attempt error recovery
*/
cmn_err(CE_NOTE, "!error in %s", masterfile);
while (token != MF_NEWLINE && token != MF_EOF)
token = mf_lex(file, tokval, sizeof (tokval));
parse_state = MF_INIT;
continue;
}
token = mf_lex(file, tokval, sizeof (tokval));
}
return (m);
}
void
process_master_file()
{
struct _buf *file;
master_rec_t *m;
if ((file = kobj_open_file(masterfile)) == NULL) {
cmn_err(CE_WARN, "!cannot open master file: %s", masterfile);
return;
}
while ((m = get_line(file)) != NULL) {
m->next = master_list;
master_list = m;
}
kobj_close_file(file);
}
/*
* Return the first master file record found matching pnpid list
*/
const master_rec_t *
master_file_lookup(device_id_t *pnpid)
{
master_rec_t *m;
device_id_t *d;
while (pnpid != NULL) {
m = master_list;
while (m != NULL) {
d = m->device_ids;
while (d != NULL) {
if (strcmp(pnpid->id, d->id) == 0)
return (m);
d = d->next;
}
m = m->next;
}
pnpid = pnpid->next;
}
return (NULL);
}