[libpicofe.git] / gp2x / pollux_set.c

/*
 * quick tool to set various timings for Wiz
 *
 * Copyright (c) Gražvydas "notaz" Ignotas, 2009
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the organization nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * HTOTAL:    X VTOTAL:  341
 * HSWIDTH:   1 VSWIDTH:   0
 * HASTART:  37 VASTART:  17
 * HAEND:   277 VAEND:   337
 *
 * 120Hz
 * pcd  8, 447: + 594us
 * pcd  9, 397: +  36us
 * pcd 10, 357: - 523us
 * pcd 11, 325: +1153us
 *
 * 'lcd_timings=397,1,37,277,341,0,17,337;dpc_clkdiv0=9'
 * 'ram_timings=2,9,4,1,1,1,1'
 */

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

/* parse stuff */
static int parse_lcd_timings(const char *str, void *data)
{
	int *lcd_timings = data;
	const char *p = str;
	int ret, c;
	ret = sscanf(str, "%d,%d,%d,%d,%d,%d,%d,%d",
			&lcd_timings[0], &lcd_timings[1], &lcd_timings[2], &lcd_timings[3],
			&lcd_timings[4], &lcd_timings[5], &lcd_timings[6], &lcd_timings[7]);
	if (ret != 8)
		return -1;
	/* skip seven commas */
	for (c = 0; c < 7 && *p != 0; p++)
		if (*p == ',')
			c++;
	if (c != 7)
		return -1;
	/* skip last number */
	while ('0' <= *p && *p <= '9')
		p++;

	return p - str;
}

static int parse_ram_timings(const char *str, void *data)
{
	int *ram_timings = data;
	const char *p = str;
	int ret, c;
	float cas;

	ret = sscanf(p, "%f,%d,%d,%d,%d,%d,%d",
			&cas, &ram_timings[1], &ram_timings[2], &ram_timings[3],
			&ram_timings[4], &ram_timings[5], &ram_timings[6]);
	if (ret != 7)
		return -1;
	if (cas == 2)
		ram_timings[0] = 1;
	else if (cas == 2.5)
		ram_timings[0] = 2;
	else if (cas == 3)
		ram_timings[0] = 3;
	else
		return -1;
	for (c = 0; c < 6 && *p != 0; p++)
		if (*p == ',')
			c++;
	if (c != 6)
		return -1;
	while ('0' <= *p && *p <= '9')
		p++;

	return p - str;
}

static int parse_decimal(const char *str, void *data)
{
	char *ep;

	*(int *)data = strtoul(str, &ep, 10);
	if (ep == str)
		return -1;

	return ep - str;
}

/* validate and apply stuff */
static int apply_lcd_timings(volatile unsigned short *memregs, void *data)
{
	int *lcd_timings = data;
	int i;

	for (i = 0; i < 8; i++) {
		if (lcd_timings[i] & ~0xffff) {
			fprintf(stderr, "pollux_set: invalid lcd timing %d: %d\n", i, lcd_timings[i]);
			return -1;
		}
	}

	for (i = 0; i < 8; i++)
		memregs[(0x307c>>1) + i] = lcd_timings[i];

	return 0;
}

static const struct {
	signed char adj;	/* how to adjust value passed by user */
	signed short min;	/* range of */
	signed short max;	/* allowed values (inclusive) */
}
ram_ranges[] = {
	{  0,  1,  3 },	/* cas (cl) */
	{ -2,  0, 15 },	/* trc */
	{ -2,  0, 15 },	/* tras */
	{  0,  0, 15 },	/* twr */
	{  0,  0, 15 },	/* tmrd */
	{  0,  0, 15 },	/* trp */
	{  0,  0, 15 },	/* trcd */
};

static int apply_ram_timings(volatile unsigned short *memregs, void *data)
{
	int *ram_timings = data;
	int i, val;

	for (i = 0; i < 7; i++)
	{
		ram_timings[i] += ram_ranges[i].adj;
		if (ram_timings[i] < ram_ranges[i].min || ram_timings[i] > ram_ranges[i].max) {
			fprintf(stderr, "pollux_set: invalid RAM timing %d\n", i);
			return -1;
		}
	}

	val = memregs[0x14802>>1] & 0x0f00;
	val |= (ram_timings[4] << 12) | (ram_timings[5] << 4) | ram_timings[6];
	memregs[0x14802>>1] = val;

	val = memregs[0x14804>>1] & 0x4000;
	val |= (ram_timings[0] << 12) | (ram_timings[1] << 8) |
		(ram_timings[2] << 4) | ram_timings[3];
	val |= 0x8000;
	memregs[0x14804>>1] = val;

	for (i = 0; i < 0x100000 && (memregs[0x14804>>1] & 0x8000); i++)
		;

	return 0;
}

static int apply_dpc_clkdiv0(volatile unsigned short *memregs, void *data)
{
	int pcd = *(int *)data;
	int tmp;

	if ((pcd - 1) & ~0x3f) {
		fprintf(stderr, "pollux_set: invalid lcd clkdiv0: %d\n", pcd);
		return -1;
	}

	pcd = (pcd - 1) & 0x3f;
	tmp = memregs[0x31c4>>1];
	memregs[0x31c4>>1] = (tmp & ~0x3f0) | (pcd << 4);

	return 0;
}

static int apply_cpuclk(volatile unsigned short *memregs, void *data)
{
	volatile unsigned int *memregl = (volatile void *)memregs;
	int mhz = *(int *)data;
	int adiv, mdiv, pdiv, sdiv = 0;
	int i, vf000, vf004;

	// m = MDIV, p = PDIV, s = SDIV
	#define SYS_CLK_FREQ 27
	pdiv = 9;
	mdiv = (mhz * pdiv) / SYS_CLK_FREQ;
	if (mdiv & ~0x3ff)
		return -1;
	vf004 = (pdiv<<18) | (mdiv<<8) | sdiv;

	// attempt to keep AHB the divider close to 250, but not higher
	for (adiv = 1; mhz / adiv > 250; adiv++)
		;

	vf000 = memregl[0xf000>>2];
	vf000 = (vf000 & ~0x3c0) | ((adiv - 1) << 6);
	memregl[0xf000>>2] = vf000;
	memregl[0xf004>>2] = vf004;
	memregl[0xf07c>>2] |= 0x8000;
	for (i = 0; (memregl[0xf07c>>2] & 0x8000) && i < 0x100000; i++)
		;

	printf("clock set to %dMHz, AHB set to %dMHz\n", mhz, mhz / adiv);
	return 0;
}

static int lcd_timings[8];
static int ram_timings[7];
static int dpc_clkdiv0;
static int cpuclk;

static const char lcd_t_help[] = "htotal,hswidth,hastart,haend,vtotal,vswidth,vastart,vaend";
static const char ram_t_help[] = "CAS,tRC,tRAS,tWR,tMRD,tRP,tRCD";

static const struct {
	const char *name;
	const char *help;
	int (*parse)(const char *str, void *data);
	int (*apply)(volatile unsigned short *memregs, void *data);
	void *data;
}
all_params[] = {
	{ "lcd_timings", lcd_t_help, parse_lcd_timings, apply_lcd_timings, lcd_timings  },
	{ "ram_timings", ram_t_help, parse_ram_timings, apply_ram_timings, ram_timings  },
	{ "dpc_clkdiv0", "divider",  parse_decimal,     apply_dpc_clkdiv0, &dpc_clkdiv0 },
	{ "clkdiv0",     "divider",  parse_decimal,     apply_dpc_clkdiv0, &dpc_clkdiv0 }, /* alias */
	{ "cpuclk",      "MHZ",      parse_decimal,     apply_cpuclk,      &cpuclk      },
};
#define ALL_PARAM_COUNT (sizeof(all_params) / sizeof(all_params[0]))

/*
 * set timings based on preformated string
 * returns 0 on success.
 */
int pollux_set(volatile unsigned short *memregs, const char *str)
{
	int parsed_params[ALL_PARAM_COUNT];
	int applied_params[ALL_PARAM_COUNT];
	int applied_something = 0;
	const char *p, *po;
	int i, ret;

	if (str == NULL)
		return -1;

	memset(parsed_params, 0, sizeof(parsed_params));
	memset(applied_params, 0, sizeof(applied_params));

	p = str;
	while (1)
	{
again:
		while (*p == ';' || *p == ' ')
			p++;
		if (*p == 0)
			break;

		for (i = 0; i < ALL_PARAM_COUNT; i++)
		{
			int param_len = strlen(all_params[i].name);
			if (strncmp(p, all_params[i].name, param_len) == 0 && p[param_len] == '=')
			{
				p += param_len + 1;
				ret = all_params[i].parse(p, all_params[i].data);
				if (ret < 0) {
					fprintf(stderr, "pollux_set parser: error at %-10s\n", p);
					fprintf(stderr, "  valid format is: <%s>\n", all_params[i].help);
					return -1;
				}
				parsed_params[i] = 1;
				p += ret;
				goto again;
			}
		}

		/* Unknown param. Attempt to be forward compatible and ignore it. */
		for (po = p; *p != 0 && *p != ';'; p++)
			;

		fprintf(stderr, "unhandled param: ");
		fwrite(po, 1, p - po, stderr);
		fprintf(stderr, "\n");
	}

	/* validate and apply */
	for (i = 0; i < ALL_PARAM_COUNT; i++)
	{
		if (!parsed_params[i])
			continue;

		ret = all_params[i].apply(memregs, all_params[i].data);
		if (ret < 0) {
			fprintf(stderr, "pollux_set: failed to apply %s (bad value?)\n",
				all_params[i].name);
			continue;
		}

		applied_something = 1;
		applied_params[i] = 1;
	}

	if (applied_something)
	{
		int c;
		printf("applied: ");
		for (i = c = 0; i < ALL_PARAM_COUNT; i++)
		{
			if (!applied_params[i])
				continue;
			if (c != 0)
				printf(", ");
			printf("%s", all_params[i].name);
			c++;
		}
		printf("\n");
	}

	return 0;
}

int pollux_set_fromenv(volatile unsigned short *memregs,
	const char *env_var)
{
	const char *set_string;
	int ret = -1;

	set_string = getenv(env_var);
	if (set_string)
		ret = pollux_set(memregs, set_string);
	else
		printf("env var %s not defined.\n", env_var);

	return ret;
}

#ifdef BINARY
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>

static void usage(const char *binary)
{
	int i;
	printf("usage:\n%s <set_str[;set_str[;...]]>\n"
		"set_str:\n", binary);
	for (i = 0; i < ALL_PARAM_COUNT; i++)
		printf("  %s=<%s>\n", all_params[i].name, all_params[i].help);
}

int main(int argc, char *argv[])
{
	volatile unsigned short *memregs;
	int ret, memdev;

	if (argc != 2) {
		usage(argv[0]);
		return 1;
	}

	memdev = open("/dev/mem", O_RDWR);
	if (memdev == -1)
	{
		perror("open(/dev/mem) failed");
		return 1;
	}

	memregs	= mmap(0, 0x20000, PROT_READ|PROT_WRITE, MAP_SHARED, memdev, 0xc0000000);
	if (memregs == MAP_FAILED)
	{
		perror("mmap(memregs) failed");
		close(memdev);
		return 1;
	}

	ret = pollux_set(memregs, argv[1]);

	munmap((void *)memregs, 0x20000);
	close(memdev);

	return ret;
}
#endif
Commit	Line	Data
fa8d1331	1	/*
	2	* quick tool to set various timings for Wiz
	3	*
	4	* Copyright (c) Gražvydas "notaz" Ignotas, 2009
	5	*
	6	* Redistribution and use in source and binary forms, with or without
	7	* modification, are permitted provided that the following conditions are met:
	8	* * Redistributions of source code must retain the above copyright
	9	* notice, this list of conditions and the following disclaimer.
	10	* * 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	* * Neither the name of the organization nor the
	14	* names of its contributors may be used to endorse or promote products
	15	* derived from this software without specific prior written permission.
	16	*
	17	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	18	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	19	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	20	* ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
	21	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	22	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	23	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	24	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	25	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	26	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	27	*
	28	* HTOTAL: X VTOTAL: 341
	29	* HSWIDTH: 1 VSWIDTH: 0
	30	* HASTART: 37 VASTART: 17
	31	* HAEND: 277 VAEND: 337
	32	*
	33	* 120Hz
	34	* pcd 8, 447: + 594us
	35	* pcd 9, 397: + 36us
	36	* pcd 10, 357: - 523us
	37	* pcd 11, 325: +1153us
	38	*
	39	* 'lcd_timings=397,1,37,277,341,0,17,337;dpc_clkdiv0=9'
	40	* 'ram_timings=2,9,4,1,1,1,1'
	41	*/
	42
	43	#include <stdio.h>
	44	#include <stdlib.h>
	45	#include <string.h>
	46	#include "pollux_set.h"
	47
	48	/* parse stuff */
	49	static int parse_lcd_timings(const char str, void data)
	50	{
	51	int *lcd_timings = data;
	52	const char *p = str;
	53	int ret, c;
	54	ret = sscanf(str, "%d,%d,%d,%d,%d,%d,%d,%d",
	55	&lcd_timings[0], &lcd_timings[1], &lcd_timings[2], &lcd_timings[3],
	56	&lcd_timings[4], &lcd_timings[5], &lcd_timings[6], &lcd_timings[7]);
	57	if (ret != 8)
	58	return -1;
	59	/* skip seven commas */
	60	for (c = 0; c < 7 && *p != 0; p++)
	61	if (*p == ',')
	62	c++;
	63	if (c != 7)
	64	return -1;
65	/* skip last number */
66	while ('0' <= p && p <= '9')
67	p++;
68
69	return p - str;
70	}
71
72	static int parse_ram_timings(const char str, void data)
73	{
74	int *ram_timings = data;
75	const char *p = str;
76	int ret, c;
77	float cas;
78
79	ret = sscanf(p, "%f,%d,%d,%d,%d,%d,%d",
80	&cas, &ram_timings[1], &ram_timings[2], &ram_timings[3],
81	&ram_timings[4], &ram_timings[5], &ram_timings[6]);
82	if (ret != 7)
83	return -1;
84	if (cas == 2)
85	ram_timings[0] = 1;
86	else if (cas == 2.5)
87	ram_timings[0] = 2;
88	else if (cas == 3)
89	ram_timings[0] = 3;
90	else
91	return -1;
92	for (c = 0; c < 6 && *p != 0; p++)
93	if (*p == ',')
94	c++;
95	if (c != 6)
96	return -1;
97	while ('0' <= p && p <= '9')
98	p++;
99
100	return p - str;
101	}
102
103	static int parse_decimal(const char str, void data)
104	{
105	char *ep;
106
107	(int )data = strtoul(str, &ep, 10);
108	if (ep == str)
109	return -1;
110
111	return ep - str;
112	}
113
114	/* validate and apply stuff */
115	static int apply_lcd_timings(volatile unsigned short memregs, void data)
116	{
117	int *lcd_timings = data;
118	int i;
119
120	for (i = 0; i < 8; i++) {
121	if (lcd_timings[i] & ~0xffff) {
122	fprintf(stderr, "pollux_set: invalid lcd timing %d: %d\n", i, lcd_timings[i]);
123	return -1;
124	}
125	}
126
127	for (i = 0; i < 8; i++)
128	memregs[(0x307c>>1) + i] = lcd_timings[i];
129
130	return 0;
131	}
132
133	static const struct {
134	signed char adj; /* how to adjust value passed by user */
135	signed short min; /* range of */
136	signed short max; /* allowed values (inclusive) */
137	}
138	ram_ranges[] = {
139	{ 0, 1, 3 }, /* cas (cl) */
140	{ -2, 0, 15 }, /* trc */
141	{ -2, 0, 15 }, /* tras */
142	{ 0, 0, 15 }, /* twr */
143	{ 0, 0, 15 }, /* tmrd */
144	{ 0, 0, 15 }, /* trp */
145	{ 0, 0, 15 }, /* trcd */
146	};
147
148	static int apply_ram_timings(volatile unsigned short memregs, void data)
149	{
150	int *ram_timings = data;
151	int i, val;
152
153	for (i = 0; i < 7; i++)
154	{
155	ram_timings[i] += ram_ranges[i].adj;
156	if (ram_timings[i] < ram_ranges[i].min \|\| ram_timings[i] > ram_ranges[i].max) {
157	fprintf(stderr, "pollux_set: invalid RAM timing %d\n", i);
158	return -1;
159	}
160	}
161
162	val = memregs[0x14802>>1] & 0x0f00;
163	val \|= (ram_timings[4] << 12) \| (ram_timings[5] << 4) \| ram_timings[6];
164	memregs[0x14802>>1] = val;
165
166	val = memregs[0x14804>>1] & 0x4000;
167	val \|= (ram_timings[0] << 12) \| (ram_timings[1] << 8) \|
168	(ram_timings[2] << 4) \| ram_timings[3];
169	val \|= 0x8000;
170	memregs[0x14804>>1] = val;
171
172	for (i = 0; i < 0x100000 && (memregs[0x14804>>1] & 0x8000); i++)
173	;
174
175	return 0;
176	}
177
178	static int apply_dpc_clkdiv0(volatile unsigned short memregs, void data)
179	{
180	int pcd = (int )data;
181	int tmp;
182
183	if ((pcd - 1) & ~0x3f) {
184	fprintf(stderr, "pollux_set: invalid lcd clkdiv0: %d\n", pcd);
185	return -1;
186	}
187
188	pcd = (pcd - 1) & 0x3f;
189	tmp = memregs[0x31c4>>1];
190	memregs[0x31c4>>1] = (tmp & ~0x3f0) \| (pcd << 4);
191
192	return 0;
193	}
194
195	static int apply_cpuclk(volatile unsigned short memregs, void data)
196	{
197	volatile unsigned int memregl = (volatile void )memregs;
198	int mhz = (int )data;
b0eec793	199	int adiv, mdiv, pdiv, sdiv = 0;
b0eec793	200	int i, vf000, vf004;
fa8d1331	201
	202	// m = MDIV, p = PDIV, s = SDIV
	203	#define SYS_CLK_FREQ 27
	204	pdiv = 9;
	205	mdiv = (mhz * pdiv) / SYS_CLK_FREQ;
	206	if (mdiv & ~0x3ff)
	207	return -1;
b0eec793	208	vf004 = (pdiv<<18) \| (mdiv<<8) \| sdiv;
fa8d1331	209
b0eec793	210	// attempt to keep AHB the divider close to 250, but not higher
	211	for (adiv = 1; mhz / adiv > 250; adiv++)
	212	;
	213
	214	vf000 = memregl[0xf000>>2];
	215	vf000 = (vf000 & ~0x3c0) \| ((adiv - 1) << 6);
	216	memregl[0xf000>>2] = vf000;
	217	memregl[0xf004>>2] = vf004;
fa8d1331	218	memregl[0xf07c>>2] \|= 0x8000;
	219	for (i = 0; (memregl[0xf07c>>2] & 0x8000) && i < 0x100000; i++)
	220	;
	221
b0eec793	222	printf("clock set to %dMHz, AHB set to %dMHz\n", mhz, mhz / adiv);
fa8d1331	223	return 0;
	224	}
	225
	226	static int lcd_timings[8];
	227	static int ram_timings[7];
	228	static int dpc_clkdiv0;
	229	static int cpuclk;
	230
	231	static const char lcd_t_help[] = "htotal,hswidth,hastart,haend,vtotal,vswidth,vastart,vaend";
	232	static const char ram_t_help[] = "CAS,tRC,tRAS,tWR,tMRD,tRP,tRCD";
	233
	234	static const struct {
	235	const char *name;
	236	const char *help;
	237	int (parse)(const char str, void *data);
	238	int (apply)(volatile unsigned short memregs, void *data);
	239	void *data;
	240	}
	241	all_params[] = {
	242	{ "lcd_timings", lcd_t_help, parse_lcd_timings, apply_lcd_timings, lcd_timings },
	243	{ "ram_timings", ram_t_help, parse_ram_timings, apply_ram_timings, ram_timings },
	244	{ "dpc_clkdiv0", "divider", parse_decimal, apply_dpc_clkdiv0, &dpc_clkdiv0 },
	245	{ "clkdiv0", "divider", parse_decimal, apply_dpc_clkdiv0, &dpc_clkdiv0 }, /* alias */
	246	{ "cpuclk", "MHZ", parse_decimal, apply_cpuclk, &cpuclk },
	247	};
	248	#define ALL_PARAM_COUNT (sizeof(all_params) / sizeof(all_params[0]))
	249
	250	/*
	251	* set timings based on preformated string
	252	* returns 0 on success.
	253	*/
	254	int pollux_set(volatile unsigned short memregs, const char str)
	255	{
	256	int parsed_params[ALL_PARAM_COUNT];
	257	int applied_params[ALL_PARAM_COUNT];
	258	int applied_something = 0;
	259	const char p, po;
	260	int i, ret;
	261
	262	if (str == NULL)
	263	return -1;
	264
	265	memset(parsed_params, 0, sizeof(parsed_params));
	266	memset(applied_params, 0, sizeof(applied_params));
	267
	268	p = str;
	269	while (1)
	270	{
	271	again:
	272	while (p == ';' \|\| p == ' ')
	273	p++;
	274	if (*p == 0)
	275	break;
	276
	277	for (i = 0; i < ALL_PARAM_COUNT; i++)
	278	{
	279	int param_len = strlen(all_params[i].name);
	280	if (strncmp(p, all_params[i].name, param_len) == 0 && p[param_len] == '=')
	281	{
	282	p += param_len + 1;
	283	ret = all_params[i].parse(p, all_params[i].data);
	284	if (ret < 0) {
	285	fprintf(stderr, "pollux_set parser: error at %-10s\n", p);
	286	fprintf(stderr, " valid format is: <%s>\n", all_params[i].help);
287	return -1;
288	}
289	parsed_params[i] = 1;
290	p += ret;
291	goto again;
292	}
293	}
294
295	/* Unknown param. Attempt to be forward compatible and ignore it. */
296	for (po = p; p != 0 && p != ';'; p++)
297	;
298
299	fprintf(stderr, "unhandled param: ");
300	fwrite(po, 1, p - po, stderr);
301	fprintf(stderr, "\n");
302	}
303
304	/* validate and apply */
305	for (i = 0; i < ALL_PARAM_COUNT; i++)
306	{
307	if (!parsed_params[i])
308	continue;
309
310	ret = all_params[i].apply(memregs, all_params[i].data);
311	if (ret < 0) {
312	fprintf(stderr, "pollux_set: failed to apply %s (bad value?)\n",
313	all_params[i].name);
314	continue;
315	}
316
317	applied_something = 1;
318	applied_params[i] = 1;
319	}
320
321	if (applied_something)
322	{
323	int c;
324	printf("applied: ");
325	for (i = c = 0; i < ALL_PARAM_COUNT; i++)
326	{
327	if (!applied_params[i])
328	continue;
329	if (c != 0)
330	printf(", ");
331	printf("%s", all_params[i].name);
332	c++;
333	}
334	printf("\n");
335	}
336
337	return 0;
338	}
339
9a5a0dc9	340	int pollux_set_fromenv(volatile unsigned short *memregs,
	341	const char *env_var)
	342	{
	343	const char *set_string;
	344	int ret = -1;
	345
	346	set_string = getenv(env_var);
	347	if (set_string)
	348	ret = pollux_set(memregs, set_string);
	349	else
	350	printf("env var %s not defined.\n", env_var);
	351
	352	return ret;
	353	}
	354
fa8d1331	355	#ifdef BINARY
	356	#include <sys/types.h>
	357	#include <sys/stat.h>
	358	#include <fcntl.h>
	359	#include <sys/mman.h>
	360	#include <unistd.h>
	361
	362	static void usage(const char *binary)
	363	{
	364	int i;
	365	printf("usage:\n%s <set_str[;set_str[;...]]>\n"
	366	"set_str:\n", binary);
	367	for (i = 0; i < ALL_PARAM_COUNT; i++)
	368	printf(" %s=<%s>\n", all_params[i].name, all_params[i].help);
	369	}
	370
	371	int main(int argc, char *argv[])
	372	{
	373	volatile unsigned short *memregs;
	374	int ret, memdev;
	375
	376	if (argc != 2) {
	377	usage(argv[0]);
	378	return 1;
	379	}
	380
	381	memdev = open("/dev/mem", O_RDWR);
	382	if (memdev == -1)
	383	{
	384	perror("open(/dev/mem) failed");
	385	return 1;
	386	}
	387
	388	memregs = mmap(0, 0x20000, PROT_READ\|PROT_WRITE, MAP_SHARED, memdev, 0xc0000000);
	389	if (memregs == MAP_FAILED)
	390	{
	391	perror("mmap(memregs) failed");
	392	close(memdev);
	393	return 1;
	394	}
	395
	396	ret = pollux_set(memregs, argv[1]);
	397
	398	munmap((void *)memregs, 0x20000);
	399	close(memdev);
	400
	401	return ret;
	402	}
	403	#endif