setup.c

microwindows移植到S3C44B0的源码

 * a param_struct).  The list is terminated with a zero-length tag (this tag
 * is not parsed in any way).
 */
static int __init parse_tag_core(const struct tag *tag)
{
	if ((tag->u.core.flags & 1) == 0)
		root_mountflags &= ~MS_RDONLY;
	ROOT_DEV = to_kdev_t(tag->u.core.rootdev);
	return 0;
}

static int __init parse_tag_mem32(const struct tag *tag)
{
	if (meminfo.nr_banks >= NR_BANKS) {
		printk(KERN_WARNING
		       "Ignoring memory bank 0x%08x size %dKB\n",
			tag->u.mem.start, tag->u.mem.size / 1024);
		return -EINVAL;
	}
	meminfo.bank[meminfo.nr_banks].start = tag->u.mem.start;
	meminfo.bank[meminfo.nr_banks].size  = tag->u.mem.size;
	meminfo.bank[meminfo.nr_banks].node  = 0;
	meminfo.nr_banks += 1;

	return 0;
}

static int __init parse_tag_videotext(const struct tag *tag)
{
	screen_info.orig_x            = tag->u.videotext.x;
	screen_info.orig_y            = tag->u.videotext.y;
	screen_info.orig_video_page   = tag->u.videotext.video_page;
	screen_info.orig_video_mode   = tag->u.videotext.video_mode;
	screen_info.orig_video_cols   = tag->u.videotext.video_cols;
	screen_info.orig_video_ega_bx = tag->u.videotext.video_ega_bx;
	screen_info.orig_video_lines  = tag->u.videotext.video_lines;
	screen_info.orig_video_isVGA  = tag->u.videotext.video_isvga;
	screen_info.orig_video_points = tag->u.videotext.video_points;
	return 0;
}

static int __init parse_tag_ramdisk(const struct tag *tag)
{
	setup_ramdisk((tag->u.ramdisk.flags & 1) == 0,
		      (tag->u.ramdisk.flags & 2) == 0,
		      tag->u.ramdisk.start, tag->u.ramdisk.size);
	return 0;
}

static int __init parse_tag_initrd(const struct tag *tag)
{
	setup_initrd(tag->u.initrd.start, tag->u.initrd.size);
	return 0;
}

static int __init parse_tag_serialnr(const struct tag *tag)
{
	system_serial_low = tag->u.serialnr.low;
	system_serial_high = tag->u.serialnr.high;
	return 0;
}

static int __init parse_tag_revision(const struct tag *tag)
{
	system_rev = tag->u.revision.rev;
	return 0;
}

static int __init parse_tag_cmdline(const struct tag *tag)
{
	strncpy(default_command_line, tag->u.cmdline.cmdline, COMMAND_LINE_SIZE);
	default_command_line[COMMAND_LINE_SIZE - 1] = '\0';
	return 0;
}

/*
 * This is the core tag table; these are the tags
 * that we recognise for any machine type.
 */
static const struct tagtable core_tagtable[] __init = {
	{ ATAG_CORE,      parse_tag_core      },
	{ ATAG_MEM,       parse_tag_mem32     },
	{ ATAG_VIDEOTEXT, parse_tag_videotext },
	{ ATAG_RAMDISK,   parse_tag_ramdisk   },
	{ ATAG_INITRD,    parse_tag_initrd    },
	{ ATAG_SERIAL,    parse_tag_serialnr  },
	{ ATAG_REVISION,  parse_tag_revision  },
	{ ATAG_CMDLINE,   parse_tag_cmdline   }
};

/*
 * Scan one tag table for this tag, and call its parse function.
 */
static int __init
parse_tag(const struct tagtable *tbl, int size, const struct tag *t)
{
	int i;

	for (i = 0; i < size; i++, tbl++)
		if (t->hdr.tag == tbl->tag) {
			tbl->parse(t);
			break;
		}

	return i < size;
}

/*
 * Parse all tags in the list, checking both the global and architecture
 * specific tag tables.
 */
static void __init
parse_tags(const struct tagtable *tbl, int size, const struct tag *t)
{
	/*
	 * The tag list is terminated with a zero-sized tag.  Size is
	 * defined to be in units of 32-bit quantities.
	 */
	for (; t->hdr.size; t = (struct tag *)((u32 *)t + t->hdr.size)) {
		if (parse_tag(core_tagtable, ARRAY_SIZE(core_tagtable), t))
			continue;

		if (tbl && parse_tag(tbl, size, t))
			continue;

		printk(KERN_WARNING
		       "Ignoring unrecognised tag 0x%08x\n", t->hdr.tag);
	}
}

static void __init parse_params(struct param_struct *params)
{
	if (params->u1.s.page_size != PAGE_SIZE) {
		printk(KERN_WARNING "Warning: bad configuration page, "
		       "trying to continue\n");
		return;
	}

	ROOT_DEV	   = to_kdev_t(params->u1.s.rootdev);
	system_rev	   = params->u1.s.system_rev;
	system_serial_low  = params->u1.s.system_serial_low;
	system_serial_high = params->u1.s.system_serial_high;

	if (params->u1.s.mem_fclk_21285 > 0)
		mem_fclk_21285 = params->u1.s.mem_fclk_21285;  

	setup_ramdisk((params->u1.s.flags & FLAG_RDLOAD) == 0,
		      (params->u1.s.flags & FLAG_RDPROMPT) == 0,
		      params->u1.s.rd_start,
		      params->u1.s.ramdisk_size);

	setup_initrd(params->u1.s.initrd_start,
		     params->u1.s.initrd_size);

	if (!(params->u1.s.flags & FLAG_READONLY))
		root_mountflags &= ~MS_RDONLY;

	strncpy(default_command_line, params->commandline, COMMAND_LINE_SIZE);
	default_command_line[COMMAND_LINE_SIZE - 1] = '\0';

	if (meminfo.nr_banks == 0) {
		meminfo.nr_banks      = 1;
		meminfo.bank[0].start = PHYS_OFFSET;
		meminfo.bank[0].size  = params->u1.s.nr_pages << PAGE_SHIFT;
	}
}


/*
 * Tell the kernel about any console devices we may have,  the user
 * can use bootargs select which one they get.  The default will be
 * the console you register first.
 */



void __init setup_arch(char **cmdline_p)
{
	struct param_struct *params = NULL;
	struct machine_desc *mdesc;
	char *from = default_command_line;
	int bootmap_size;
	unsigned long memory_start = (unsigned long)&_end_kernel;
#ifdef CONFIG_ARCH_CNXT
	unsigned long memory_end = END_MEM;
#endif
	
	ROOT_DEV = MKDEV(0, 255);

	setup_processor();
	mdesc = setup_architecture(machine_arch_type);
        printk("machine_arch_type is %d,PAGE_OFFSET is 0x%08x,END_MEM is 0x%08x\n",machine_arch_type,PAGE_OFFSET,END_MEM);
	machine_name = mdesc->name;

	if (mdesc->soft_reboot)
		reboot_setup("s");

	if (mdesc->param_offset)
		params = (struct param_struct*)
			(phys_to_virt(mdesc->param_offset));

	/*
	 * Do the machine-specific fixups before we parse the
	 * parameters or tags.
	 */
	if (mdesc->fixup)
		mdesc->fixup(mdesc, params, &from, &meminfo);

	if (params) {
		struct tag *tag = (struct tag *)params;

		/*
		 * Is the first tag the CORE tag?  This differentiates
		 * between the tag list and the parameter table.
		 */
		if (tag->hdr.tag == ATAG_CORE)
			parse_tags(mdesc->tagtable, mdesc->tagsize, tag);
		else
			parse_params(params);
	} 

	if (meminfo.nr_banks == 0) {
		meminfo.nr_banks      = 1;
		meminfo.bank[0].start = PAGE_OFFSET;//PHYS_OFFSET;
		meminfo.bank[0].size  = MEM_SIZE;
	}

	init_mm.start_code = (unsigned long) &_text;
	init_mm.end_code   = (unsigned long) &_etext;
	init_mm.end_data   = (unsigned long) &_edata;
	init_mm.brk	   = (unsigned long) &_end;

	memcpy(saved_command_line, from, COMMAND_LINE_SIZE);
	printk("CGP: command line is %s\n", saved_command_line);
	saved_command_line[COMMAND_LINE_SIZE-1] = '\0';
	parse_cmdline(&meminfo, cmdline_p, from);

#if 1
	bootmem_init(&meminfo);
#else
	bootmap_size= init_bootmem_node(
			  NODE_DATA(0),
			  memory_start >> PAGE_SHIFT,
			  PAGE_OFFSET >> PAGE_SHIFT,
			  END_MEM >> PAGE_SHIFT);
 
	free_bootmem(memory_start, END_MEM - memory_start);
	reserve_bootmem(memory_start, bootmap_size);
#endif
	paging_init(&meminfo, mdesc);		// mem_map is set up here! 
	request_standard_resources(&meminfo, mdesc);

	/*
	 * Set up various architecture-specific pointers
	 */
	init_arch_irq = mdesc->init_irq;

#ifdef CONFIG_VT
#if defined(CONFIG_VGA_CONSOLE)
	conswitchp = &vga_con;
#elif defined(CONFIG_DUMMY_CONSOLE)
	conswitchp = &dummy_con;
#endif
#endif
}

int get_cpuinfo(char * buffer)
{
	char *p = buffer;

	p += sprintf(p, "Processor\t: %s %s rev %d (%s)\n",
		     proc_info.manufacturer, proc_info.cpu_name,
		     (int)processor_id & 15, elf_platform);

	p += sprintf(p, "BogoMIPS\t: %lu.%02lu\n",
		     loops_per_jiffy / (500000/HZ),
		     (loops_per_jiffy / (5000/HZ)) % 100);

	p += sprintf(p, "Hardware\t: %s\n", machine_name);

	p += sprintf(p, "Revision\t: %04x\n",
		     system_rev);

	p += sprintf(p, "Serial\t\t: %08x%08x\n",
		     system_serial_high,
		     system_serial_low);

	return p - buffer;
}


/*
 *	Get CPU information for use by the procfs.
 */

static int show_cpuinfo(struct seq_file *m, void *v)
{
	seq_printf(m, "Processor\t: %s %s rev %d (%s)\n",
		     proc_info.manufacturer, proc_info.cpu_name,
		     (int)processor_id & 15, elf_platform);

	seq_printf(m, "BogoMIPS\t: %lu.%02lu\n",
		     loops_per_jiffy / (500000/HZ),
		     (loops_per_jiffy / (5000/HZ)) % 100);

	seq_printf(m, "Hardware\t: %s\n", machine_name);

	seq_printf(m, "Revision\t: %04x\n",
		     system_rev);

	seq_printf(m, "Serial\t\t: %08x%08x\n",
		     system_serial_high,
		     system_serial_low);

	return 0;
}

static void *c_start(struct seq_file *m, loff_t *pos)
{
	return *pos < NR_CPUS ? ((void *) 0x12345678) : NULL;
}

static void *c_next(struct seq_file *m, void *v, loff_t *pos)
{
	++*pos;
	return c_start(m, pos);
}

static void c_stop(struct seq_file *m, void *v)
{
}

struct seq_operations cpuinfo_op = {
	start:	c_start,
	next:	c_next,
	stop:	c_stop,
	show:	show_cpuinfo,
};