Пример #1
0
/* Args looks like "foo=bar,bar2 baz=fuz wiz". */
int parse_mem_args(unsigned long *ret_start_addr, unsigned long *ret_size)
{
	char *param = NULL, *val = NULL;
	char *endp;
	unsigned long start;
	unsigned long long size;
	char *name = "mem";
	char *args = NULL;
	char *bootargs_env = getenv("bootargs");
	static char bootargs[1024] = { 0 };

	if (NULL == ret_start_addr || NULL == ret_size
		|| NULL == bootargs_env)
		goto error_out;

	memcpy(bootargs, bootargs_env, sizeof(bootargs));
	args = bootargs;

	/* Chew leading spaces */
	args = skip_spaces(args);

	while (*args) {
		args = next_arg(args, &param, &val);

		if (parameq(name, param))
			break;
	}

	if (NULL == param)
		goto error_out;

	if (parameq(name, param) == 0)
		goto error_out;

	if (!val)
		goto error_out;

	start = CFG_DDR_PHYS_OFFSET;
	size = memparse(val, &endp);
	if (*endp == '@')
		start = memparse(endp + 1, NULL);

	*ret_start_addr = start;
	*ret_size = size;

	return 0;
error_out:
	return -1;
}
Пример #2
0
static int parse_one(char *param,
		     char *val,
		     struct kernel_param *params, 
		     unsigned num_params,
		     int (*handle_unknown)(char *param, char *val))
{
	unsigned int i;

	/* Find parameter */
	for (i = 0; i < num_params; i++) {
		if (parameq(param, params[i].name)) {
			DEBUGP("They are equal!  Calling %p\n",
			       params[i].set);
			return params[i].set(val, &params[i]);
		}
	}

	if (handle_unknown) {
		DEBUGP("Unknown argument: calling %p\n", handle_unknown);
		return handle_unknown(param, val);
	}

	DEBUGP("Unknown argument `%s'\n", param);
	return -ENOENT;
}
Пример #3
0
static int parse_one(char *param,
		     char *val,
		     const struct kernel_param *params,
		     unsigned num_params,
		     int (*handle_unknown)(char *param, char *val))
{
	unsigned int i;
	int err;

	/* Find parameter */
	for (i = 0; i < num_params; i++) {
		if (parameq(param, params[i].name)) {
			/* No one handled NULL, so do it here. */
			if (!val && params[i].ops->set != param_set_bool)
				return -EINVAL;
			DEBUGP("They are equal!  Calling %p\n",
			       params[i].ops->set);
			mutex_lock(&param_lock);
			err = params[i].ops->set(val, &params[i]);
			mutex_unlock(&param_lock);
			return err;
		}
	}

	if (handle_unknown) {
		DEBUGP("Unknown argument: calling %p\n", handle_unknown);
		return handle_unknown(param, val);
	}

	DEBUGP("Unknown argument `%s'\n", param);
	return -ENOENT;
}
Пример #4
0
static int parse_one(char *param,
		     char *val,
		     struct kernel_param *params, 
		     unsigned num_params,
		     int (*handle_unknown)(char *param, char *val))
{
	unsigned int i;
printk("in parse_one(%s, %s)\n", param, val);

	/* Find parameter */
	for (i = 0; i < num_params; i++) {
		if (parameq(param, params[i].name)) {
			DEBUGP("They are equal!  Calling %p\n",
			       params[i].set);
			return params[i].set(val, &params[i]);
		}
	}

	if (handle_unknown) {
		DEBUGP("Unknown argument: calling %p\n", handle_unknown);
		return handle_unknown(param, val);
	}

	/* Ignore unknown args if no handle_unknown function specified */
	printk("Unknown argument `%s'\n", param);
	return 0;
}
Пример #5
0
/* Check for early params. */
static int __init do_early_param(char *param, char *val, const char *unused)
{
	const struct vmm_setup_param *p;

        for (p = __setup_start; p < __setup_end; p++) {
                if ((p->early && parameq(param, p->str)) ||
			(strcmp(param, "console") == 0 &&
				strcmp(p->str, "earlycon") == 0)
			) {
                        p->setup_func(val);
                }
        }
        /* We accept everything at this stage. */
        return 0;
}
Пример #6
0
/* Check for early params. */
static int __init do_early_param(char *param, char *val)
{
	const struct obs_kernel_param *p;

	for (p = __setup_start; p < __setup_end; p++) {
		if ((p->early && parameq(param, p->str)) ||
		    (strcmp(param, "console") == 0 &&
		     strcmp(p->str, "earlycon") == 0)
		) {
			if (p->setup_func(val) != 0)
				printk(KERN_WARNING
				       "Malformed early option '%s'\n", param);
		}
	}
	/* We accept everything at this stage. */
	return 0;
}