path: root/usr/src/lib/efcode/engine/properties.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 (c) 2000 by Sun Microsystems, Inc.
 * All rights reserved.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <fcode/private.h>
#include <fcode/log.h>

void
create_prop(fcode_env_t *env, char *name)
{
	push_a_string(env, name);
	property(env);
}

void
create_int_prop(fcode_env_t *env, char *name, int val)
{
	PUSH(DS, val);
	encode_int(env);
	create_prop(env, name);
}

void
create_string_prop(fcode_env_t *env, char *name, char *val)
{
	push_a_string(env, val);
	encode_string(env);
	create_prop(env, name);
}

static int
addr_cmp(void *a, void *b)
{
	return ((uchar_t *)a == (uchar_t *)b);
}

static void *
add_property_buffer(fcode_env_t *env, int len)
{
	void *data = MALLOC(len+1);
	return (add_resource(&env->propbufs, data, addr_cmp));
}

static void
free_property_buffer(fcode_env_t *env, void *buffer)
{
	free_resource(&env->propbufs, buffer, addr_cmp);
	FREE(buffer);
}

/*
 * Golden Rule:
 * DO NOT cache the value of the head of the property list *before*
 * looking up a property.
 * This routine is also responsible for purging dead properties
 * and that *can* affect the head pointer.
 * you have been warned!
 */
prop_t *
find_property(device_t *d, char *name)
{
	prop_t *p = d->properties, *prev;
	prop_t *found = NULL;

	prev = NULL;
	while (p && !found) {
		if (p->name) {
			if (strcmp(name, p->name) == 0) {
				found = p;
			}
			prev = p;
			p = p->next;
		} else {
			prop_t *dead;

			if (prev)
				prev->next = p->next;
			else {
				/* last prop in chain */
				d->properties = p->next;
			}
			dead = p;
			p = p->next;
			FREE(dead->name);
			FREE(dead->data);
			FREE(dead);
		}
	}
	return (found);
}

static prop_t *
stack_find_property(fcode_env_t *env, device_t *d)
{
	char *propname;

	propname = pop_a_string(env, NULL);
	return (find_property(d, propname));
}

void
property(fcode_env_t *env)
{
	int datalen;
	char *propname, *srcptr;
	prop_t *p;
	device_t *d;

	CHECK_DEPTH(env, 4, "property");
	if (MYSELF) {
		d = MYSELF->device;
	} else {
		d = env->current_device;
		if (!d) {
			void *buffer;

			two_drop(env);
			if ((buffer = pop_a_string(env, NULL)) != NULL)
				free_property_buffer(env, buffer);
			return;
		}
	}
	propname = pop_a_string(env, NULL);
	p = find_property(d, propname);
	if (p == NULL) {
		p = MALLOC(sizeof (prop_t));
		p->next = d->properties;
		d->properties = p;
		p->name = STRDUP(propname);
	} else if (p->data)
		FREE(p->data);	/* release old resources */
	srcptr = pop_a_string(env, &datalen);
	p->data = MALLOC(datalen+1);
	p->size = datalen;
	memcpy(p->data, srcptr, datalen);
	p->data[datalen] = 0;
	if (srcptr)
		free_property_buffer(env, srcptr);
}

prop_t *
lookup_package_property(fcode_env_t *env, char *propname, device_t *d)
{
	prop_t *p;

	p = find_property(d, propname);
	if (p) {
		return (p);
	}
	if (d->vectors.get_package_prop) {
		static prop_t sp;
		fstack_t fail, n;

		/* recreate the FORTH environment for the remote call */
		push_a_string(env, propname);
		REVERT_PHANDLE(env, n, d);
		PUSH(DS, n);
		d->vectors.get_package_prop(env);
		fail = POP(DS);
		if (fail)
			return (NULL);
		sp.size = POP(DS);
		sp.data = (uchar_t *)POP(DS);
		sp.name = propname;
		sp.next = NULL;
		return (&sp);
	}
	return (NULL);
}

void
get_package_property(fcode_env_t *env)
{
	prop_t *p;
	device_t *d;
	char *propname;

	CHECK_DEPTH(env, 3, "get-package-property");
	CONVERT_PHANDLE(env, d, POP(DS));
	propname = pop_a_string(env, NULL);
	p = lookup_package_property(env, propname, d);
	if (p) {
		PUSH(DS, (fstack_t)p->data);
		PUSH(DS, p->size);
		PUSH(DS, FALSE);
	} else
		PUSH(DS, TRUE);
}

void
get_inherited_prop(fcode_env_t *env)
{
	instance_t *ih;
	device_t *dev;
	prop_t *prop;
	char *pname;
	int plen;

	/*
	 * First, we look thru the in-memory device tree for the property.
	 * If we don't find it, we call get_inherited_prop, which "knows" it's
	 * not going to find the property below the attachment point.
	 */

	CHECK_DEPTH(env, 2, "get-inherited-property");
	pname = pop_a_string(env, &plen);
	ih = MYSELF;
	if (ih) {
		for (; ih; ih = ih->parent) {
			dev = ih->device;
			prop = find_property(dev, pname);
			if (prop) {
				PUSH(DS, (fstack_t)prop->data);
				PUSH(DS, (fstack_t)prop->size);
				PUSH(DS, FALSE);
				return;
			}
		}
		if (dev->vectors.get_inherited_prop) {
			push_a_string(env, pname);
			dev->vectors.get_inherited_prop(env);
			return;
		}
	}
	PUSH(DS, TRUE);
}

void
delete_property(fcode_env_t *env)
{
	CHECK_DEPTH(env, 2, "delete-property");
	if (MYSELF) {
		prop_t *p;

		p = stack_find_property(env, MYSELF->device);
		if (p) {
			/*
			 * write the name as NULL; the space will be free'd
			 * the next time a property lookup passes this node
			 */
			p->name = NULL;
		}
	} else {
		two_drop(env);
	}
}

void
get_my_property(fcode_env_t *env)
{
	CHECK_DEPTH(env, 2, "get-my-property");
	PUSH(DS, (fstack_t)MYSELF);
	ihandle_to_phandle(env);
	get_package_property(env);
}

void
encode_string(fcode_env_t *env)
{
	char *str;
	char *prop;
	int len;

	CHECK_DEPTH(env, 2, "encode-string");
	str = pop_a_string(env, &len);

	prop = add_property_buffer(env, len);
	memcpy(prop, str, len);
	prop[len] = 0;
	PUSH(DS, (fstack_t)prop);
	PUSH(DS, len + 1);
}

void
encode_int(fcode_env_t *env)
{
	uchar_t *ptr;
	uint32_t p;

	CHECK_DEPTH(env, 1, "encode-int");
	p = POP(DS);
	ptr = add_property_buffer(env, sizeof (uint32_t));

	memcpy(ptr, (char *)&p, sizeof (uint32_t));
	PUSH(DS, (fstack_t)ptr);
	PUSH(DS, sizeof (uint32_t));
}

void
encode_phys(fcode_env_t *env)
{
	uint_t ncells;

	ncells = get_number_of_parent_address_cells(env);
	CHECK_DEPTH(env, ncells, "encode-phys");
	encode_int(env);
	while (--ncells) {
		rot(env);
		encode_int(env);
		encode_plus(env);
	}
}

static fstack_t
get_decoded_int(uchar_t *dp)
{
	uint32_t d;

	memcpy((char *)&d, dp, sizeof (uint32_t));
	return (d);
}

int
get_default_intprop(fcode_env_t *env, char *name, device_t *d, int def)
{
	prop_t *p;

	if (!d)		/* Kludge for testing */
		return (def);
	p = lookup_package_property(env, name, d);
	if (p == NULL)
		return (def);
	return (get_decoded_int(p->data));
}

int
get_num_addr_cells(fcode_env_t *env, device_t *d)
{
	return (get_default_intprop(env, "#address-cells", d, 2));
}

int
get_num_size_cells(fcode_env_t *env, device_t *d)
{
	return (get_default_intprop(env, "#size-cells", d, 1));
}

void
decode_phys(fcode_env_t *env)
{
	char *ptr;
	int len;
	int adr_cells;
	int offset;

	CHECK_DEPTH(env, 2, "decode-phys");
	ptr = pop_a_string(env, &len);

	adr_cells = get_num_addr_cells(env, env->current_device->parent);

	offset = sizeof (uint32_t) * adr_cells;

	PUSH(DS, (fstack_t)(ptr + offset));
	PUSH(DS, len + offset);

	while (adr_cells--) {
		fstack_t d;
		offset -= sizeof (uint32_t);
		d = get_decoded_int((uchar_t *)(ptr + offset));
		PUSH(DS, d);
	}
}

/*
 * 'reg' Fcode 0x116
 */
void
reg_prop(fcode_env_t *env)
{
	fstack_t size;

	CHECK_DEPTH(env, 1, "reg");
	size = POP(DS);
	encode_phys(env);
	PUSH(DS, size);
	encode_int(env);
	encode_plus(env);
	create_prop(env, "reg");
}

void
encode_bytes(fcode_env_t *env)
{
	char *str;
	char *prop;
	int len;

	CHECK_DEPTH(env, 2, "encode-bytes");
	str = pop_a_string(env, &len);
	prop = add_property_buffer(env, len);
	memcpy(prop, str, len);
	prop[len] = 0;
	PUSH(DS, (fstack_t)prop);
	PUSH(DS, len);
}

void
decode_int(fcode_env_t *env)
{
	char *dp;
	fstack_t d;
	int len;

	CHECK_DEPTH(env, 2, "decode-int");
	dp = pop_a_string(env, &len);
	PUSH(DS, (fstack_t)(dp + sizeof (uint32_t)));
	PUSH(DS, len - sizeof (uint32_t));
	d = get_decoded_int((uchar_t *)dp);
	PUSH(DS, d);
}

void
decode_string(fcode_env_t *env)
{
	int plen, len;
	char *dp;

	CHECK_DEPTH(env, 2, "decode-string");
	dp = pop_a_string(env, &plen);
	len = strlen(dp) + 1;
	PUSH(DS, (fstack_t)(dp + len));
	PUSH(DS, plen - len);
	PUSH(DS, (fstack_t)dp);
	PUSH(DS, len - 1);
}

void
encode_plus(fcode_env_t *env)
{
	int len1, len2;
	char *src1, *src2;
	uchar_t *new;

	CHECK_DEPTH(env, 4, "encode+");
	src1 = pop_a_string(env, &len1);
	src2 = pop_a_string(env, &len2);
	new = add_property_buffer(env, len1 + len2);
	if (src2) {
		memcpy(new, src2, len2);
		free_property_buffer(env, src2);
	}
	if (src1) {
		memcpy(new + len2, src1, len1);
		free_property_buffer(env, src1);
	}
	PUSH(DS, (fstack_t)new);
	PUSH(DS, len1 + len2);
}

static void
make_special_property(fcode_env_t *env, char *name)
{
	push_a_string(env, name);
	property(env);
}

void
device_name(fcode_env_t *env)
{
	CHECK_DEPTH(env, 2, "device-name");
	encode_string(env);
	make_special_property(env, "name");
}

void
model_prop(fcode_env_t *env)
{
	CHECK_DEPTH(env, 2, "model");
	encode_string(env);
	make_special_property(env, "model");
}

void
device_type(fcode_env_t *env)
{
	CHECK_DEPTH(env, 2, "device-type");
	encode_string(env);
	make_special_property(env, "device_type");
}

/*
 * 'next-property' Fcode implementation.
 */
void
next_property(fcode_env_t *env)
{
	device_t *phandle;
	char *previous;
	prop_t *p;

	CHECK_DEPTH(env, 3, "next-property");
	phandle = (device_t *)POP(DS);
	previous = pop_a_string(env, NULL);
	p = phandle->properties;
	if (previous == NULL)
		p = phandle->properties;
	else if (p = find_property(phandle, previous))
		p = p->next;

	for (; p != NULL && p->name == NULL; p = p->next)
		;

	if (p)
		push_a_string(env, p->name);
	else
		push_a_string(env, "");
	PUSH(DS, TRUE);
}

void
get_property(fcode_env_t *env)
{
	if (MYSELF)
		get_my_property(env);
	else if (env->current_device) {
		fstack_t d;

		REVERT_PHANDLE(env, d, env->current_device);
		PUSH(DS, d);
		get_package_property(env);
	} else {
		two_drop(env);
		log_message(MSG_WARN, "No device context\n");
	}
}

#ifdef DEBUG

static void
print_indented(char *name)
{
	log_message(MSG_INFO, "%-28s", name);
}

static void
print_string(fcode_env_t *env, uchar_t *data, int len)
{
	while (len > 0) {
		int nlen = (strlen((char *)data)+1);
		log_message(MSG_INFO, "%s\n", data);
		len -= nlen;
		data += nlen;
		if (len > 0)
			print_indented("");
	}
}

static void
print_ints(uchar_t *data, int len, int crlf)
{
	uint32_t d;

	while (len--) {
		d = get_decoded_int(data);
		log_message(MSG_INFO, "%8.8lx ", d);
		data += sizeof (uint32_t);
	}
	if (crlf)
		log_message(MSG_INFO, "\n");
}

static void
print_integer(fcode_env_t *env, uchar_t *data, int len)
{
	print_ints(data, len/sizeof (uint32_t), 1);
}

static void
print_bytes(fcode_env_t *env, uchar_t *data, int len)
{
	while (len--) {
		log_message(MSG_INFO, "%2.2x ", *data++);
	}
	log_message(MSG_INFO, "\n");
}

static void
print_bytes_indented(fcode_env_t *env, uchar_t *data, int len)
{
	int nbytes;

	for (; ; ) {
		nbytes = min(len, 16);
		print_bytes(env, data, nbytes);
		len -= nbytes;
		data += nbytes;
		if (len == 0)
			break;
		print_indented("");
	}
}

static void
print_reg(fcode_env_t *env, uchar_t *data, int len)
{
	int pcells, nlen;

	if (env->current_device != NULL &&
	    env->current_device->parent != NULL) {
		pcells = get_num_size_cells(env, env->current_device->parent);
		pcells +=  get_num_addr_cells(env, env->current_device->parent);
		nlen = pcells*sizeof (uint32_t);
		while (len > 0) {
			print_ints(data, pcells, 1);
			len -= nlen;
			data += nlen;
			if (len > 0)
				print_indented("");
		}
	} else
		print_bytes_indented(env, data, len);
}

static void
print_imap(fcode_env_t *env, uchar_t *dp, int len)
{
	int n, icells;

	if (env->current_device == NULL) {
		print_bytes_indented(env, dp, len);
		return;
	}
	n = get_num_addr_cells(env, env->current_device);

	while (len) {
		int offset;
		fstack_t data;
		device_t *node;

		offset = 0;
		data = get_decoded_int(dp+((n+1)*sizeof (uint32_t)));
		CONVERT_PHANDLE(env, node, data);
		offset += (n+2)*sizeof (uint32_t);
		print_ints(dp, (n+2), 0);
		icells = get_default_intprop(env, "#interrupt-cells", node, 1);
		print_ints(dp+offset, icells, 1);
		offset += icells*sizeof (uint32_t);
		dp += offset;
		len -= offset;
		if (len)
			print_indented("");
	}
}

static void
print_ranges(fcode_env_t *env, uchar_t *data, int len)
{
	int pcells, nlen;

	if (env->current_device != NULL &&
	    env->current_device->parent != NULL) {
		pcells = get_num_addr_cells(env, env->current_device);
		pcells += get_num_addr_cells(env, env->current_device->parent);
		pcells += get_num_size_cells(env, env->current_device);
		nlen = pcells*sizeof (uint32_t);
		while (len > 0) {
			print_ints(data, pcells, 1);
			len -= nlen;
			data += nlen;
			if (len > 0)
				print_indented("");
		}
	} else
		print_bytes_indented(env, data, len);
}

typedef struct MAGIC_PROP {
	char *name;
	void (*fn)(fcode_env_t *env, uchar_t *data, int len);
} magic_prop_t;

static magic_prop_t magic_props[] = {
	{ "name",		print_string },
	{ "device_type",	print_string },
	{ "model",		print_string },
	{ "reg",		print_reg },
	{ "assigned-addresses",	print_reg },
	{ "interrupt-map",	print_imap },
	{ "#interrupt-cells",	print_integer },
	{ "interrupt-map-mask",	print_integer },
	{ "#size-cells",	print_integer },
	{ "#address-cells",	print_integer },
	{ "ranges",		print_ranges },
	{ "device-id",		print_integer },
	{ "vendor-id",		print_integer },
	{ "class-code",		print_integer },
	{ "compatible",		print_string },
	{ "version",		print_string },
	{ "manufacturer",	print_string },
	{ NULL, NULL }
};

static void
print_content(fcode_env_t *env, char *prop, uchar_t *data, int len)
{
	magic_prop_t *p;

	for (p = magic_props; p->name; p++)
		if (strcmp(prop, p->name) == 0) {
			(*p->fn)(env, data, len);
			return;
		}
	print_bytes_indented(env, data, len);
}

void
print_property(fcode_env_t *env, prop_t *p, char *prepend)
{
	char buf[40];
	char *name = (p->name ? p->name : "<noname>");

	if (prepend) {
		(void) snprintf(buf, sizeof (buf), "%s %s", prepend, name);
		name = buf;
	}
	print_indented(name);
	if (p->name)
		print_content(env, p->name, p->data, p->size);
	else
		print_bytes_indented(env, p->data, p->size);
}

void
dot_properties(fcode_env_t *env)
{
	prop_t *p;
	instance_t *omyself;

	omyself = MYSELF;
	MYSELF = NULL;

	if (env->current_device) {
		for (p = env->current_device->properties; p; p = p->next)
			print_property(env, p, NULL);
	} else {
		log_message(MSG_INFO, "No device context\n");
	}
	MYSELF = omyself;
}

#endif

#pragma init(_init)

static void
_init(void)
{
	fcode_env_t *env = initial_env;

	ASSERT(env);
	NOTICE;

	P1275(0x110, 0,		"property",		property);
	P1275(0x111, 0,		"encode-int",		encode_int);
	P1275(0x112, 0,		"encode+",		encode_plus);
	P1275(0x113, 0,		"encode-phys",		encode_phys);
	P1275(0x114, 0,		"encode-string",	encode_string);
	P1275(0x115, 0,		"encode-bytes",		encode_bytes);
	P1275(0x116, 0,		"reg",			reg_prop);
	FCODE(0x117, 0,		"intr",			fc_obsolete);
	FCODE(0x118, 0,		"driver",		fc_historical);
	P1275(0x119, 0,		"model",		model_prop);
	P1275(0x11a, 0,		"device-type",		device_type);

	P1275(0x128, 0,		"decode-phys",		decode_phys);

	P1275(0x201, 0,		"device-name",		device_name);

	P1275(0x21a, 0,		"get-my-property",	get_my_property);
	P1275(0x21b, 0,		"decode-int",		decode_int);
	P1275(0x21c, 0,		"decode-string",	decode_string);
	P1275(0x21d, 0,		"get-inherited-property", get_inherited_prop);
	P1275(0x21e, 0,		"delete-property",	delete_property);
	P1275(0x21f, 0,		"get-package-property",	get_package_property);

	P1275(0x23d, 0,		"next-property",	next_property);

	FORTH(0,		"get-property",		get_property);
	FORTH(0,		".properties",		dot_properties);
}