[deliverable/linux.git] / arch / microblaze / kernel / module.c

/*
 * Copyright (C) 2007-2009 Michal Simek <monstr@monstr.eu>
 * Copyright (C) 2007-2009 PetaLogix
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/export.h>
#include <linux/moduleloader.h>
#include <linux/kernel.h>
#include <linux/elf.h>
#include <linux/vmalloc.h>
#include <linux/fs.h>
#include <linux/string.h>

#include <asm/pgtable.h>
#include <asm/cacheflush.h>

int apply_relocate_add(Elf32_Shdr *sechdrs, const char *strtab,
	unsigned int symindex, unsigned int relsec, struct module *module)
{

	unsigned int i;
	Elf32_Rela *rela = (void *)sechdrs[relsec].sh_addr;
	Elf32_Sym *sym;
	unsigned long int *location;
	unsigned long int value;
#if __GNUC__ < 4
	unsigned long int old_value;
#endif

	pr_debug("Applying add relocation section %u to %u\n",
		relsec, sechdrs[relsec].sh_info);

	for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rela); i++) {

		location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr +
				rela[i].r_offset;
		sym = (Elf32_Sym *)sechdrs[symindex].sh_addr +
			ELF32_R_SYM(rela[i].r_info);
		value = sym->st_value + rela[i].r_addend;

		switch (ELF32_R_TYPE(rela[i].r_info)) {

		/*
		 * Be careful! mb-gcc / mb-ld splits the relocs between the
		 * text and the reloc table. In general this means we must
		 * read the current contents of (*location), add any offset
		 * then store the result back in
		 */

		case R_MICROBLAZE_32:
#if __GNUC__ < 4
			old_value = *location;
			*location = value + old_value;

			pr_debug("R_MICROBLAZE_32 (%08lx->%08lx)\n",
				old_value, value);
#else
			*location = value;
#endif
			break;

		case R_MICROBLAZE_64:
#if __GNUC__ < 4
			/* Split relocs only required/used pre gcc4.1.1 */
			old_value = ((location[0] & 0x0000FFFF) << 16) |
					(location[1] & 0x0000FFFF);
			value += old_value;
#endif
			location[0] = (location[0] & 0xFFFF0000) |
					(value >> 16);
			location[1] = (location[1] & 0xFFFF0000) |
					(value & 0xFFFF);
#if __GNUC__ < 4
			pr_debug("R_MICROBLAZE_64 (%08lx->%08lx)\n",
				old_value, value);
#endif
			break;

		case R_MICROBLAZE_64_PCREL:
#if __GNUC__ < 4
			old_value = (location[0] & 0xFFFF) << 16 |
				(location[1] & 0xFFFF);
			value -= old_value;
#endif
			value -= (unsigned long int)(location) + 4;
			location[0] = (location[0] & 0xFFFF0000) |
					(value >> 16);
			location[1] = (location[1] & 0xFFFF0000) |
					(value & 0xFFFF);
			pr_debug("R_MICROBLAZE_64_PCREL (%08lx)\n",
				value);
			break;

		case R_MICROBLAZE_32_PCREL_LO:
			pr_debug("R_MICROBLAZE_32_PCREL_LO\n");
			break;

		case R_MICROBLAZE_64_NONE:
			pr_debug("R_MICROBLAZE_64_NONE\n");
			break;

		case R_MICROBLAZE_NONE:
			pr_debug("R_MICROBLAZE_NONE\n");
			break;

		default:
			pr_err("module %s: Unknown relocation: %u\n",
				module->name,
				ELF32_R_TYPE(rela[i].r_info));
			return -ENOEXEC;
		}
	}
	return 0;
}

int module_finalize(const Elf32_Ehdr *hdr, const Elf_Shdr *sechdrs,
		struct module *module)
{
	flush_dcache();
	return 0;
}
Commit	Line	Data
f6b165c6 MS	1	/*
	2	* Copyright (C) 2007-2009 Michal Simek <monstr@monstr.eu>
	3	* Copyright (C) 2007-2009 PetaLogix
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License version 2 as
	7	* published by the Free Software Foundation.
	8	*/
	9
d64af918	10	#include <linux/export.h>
f6b165c6 MS	11	#include <linux/moduleloader.h>
	12	#include <linux/kernel.h>
	13	#include <linux/elf.h>
	14	#include <linux/vmalloc.h>
f6b165c6 MS	15	#include <linux/fs.h>
	16	#include <linux/string.h>
	17
	18	#include <asm/pgtable.h>
a5e48b88	19	#include <asm/cacheflush.h>
f6b165c6	20
f6b165c6 MS	21	int apply_relocate_add(Elf32_Shdr sechdrs, const char strtab,
	22	unsigned int symindex, unsigned int relsec, struct module *module)
	23	{
	24
	25	unsigned int i;
	26	Elf32_Rela rela = (void )sechdrs[relsec].sh_addr;
	27	Elf32_Sym *sym;
	28	unsigned long int *location;
f6b165c6 MS	29	unsigned long int value;
	30	#if __GNUC__ < 4
	31	unsigned long int old_value;
	32	#endif
	33
	34	pr_debug("Applying add relocation section %u to %u\n",
	35	relsec, sechdrs[relsec].sh_info);
	36
	37	for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rela); i++) {
	38
	39	location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr +
	40	rela[i].r_offset;
	41	sym = (Elf32_Sym *)sechdrs[symindex].sh_addr +
	42	ELF32_R_SYM(rela[i].r_info);
	43	value = sym->st_value + rela[i].r_addend;
	44
	45	switch (ELF32_R_TYPE(rela[i].r_info)) {
	46
	47	/*
	48	* Be careful! mb-gcc / mb-ld splits the relocs between the
	49	* text and the reloc table. In general this means we must
	50	* read the current contents of (*location), add any offset
	51	* then store the result back in
	52	*/
	53
	54	case R_MICROBLAZE_32:
	55	#if __GNUC__ < 4
	56	old_value = *location;
	57	*location = value + old_value;
	58
	59	pr_debug("R_MICROBLAZE_32 (%08lx->%08lx)\n",
	60	old_value, value);
	61	#else
	62	*location = value;
	63	#endif
	64	break;
	65
	66	case R_MICROBLAZE_64:
	67	#if __GNUC__ < 4
	68	/* Split relocs only required/used pre gcc4.1.1 */
	69	old_value = ((location[0] & 0x0000FFFF) << 16) \|
	70	(location[1] & 0x0000FFFF);
	71	value += old_value;
	72	#endif
	73	location[0] = (location[0] & 0xFFFF0000) \|
	74	(value >> 16);
	75	location[1] = (location[1] & 0xFFFF0000) \|
	76	(value & 0xFFFF);
	77	#if __GNUC__ < 4
	78	pr_debug("R_MICROBLAZE_64 (%08lx->%08lx)\n",
	79	old_value, value);
	80	#endif
	81	break;
	82
	83	case R_MICROBLAZE_64_PCREL:
fadf2e60 JW	84	#if __GNUC__ < 4
fadf2e60 JW	85	old_value = (location[0] & 0xFFFF) << 16 \|
f6b165c6	86	(location[1] & 0xFFFF);
fadf2e60 JW	87	value -= old_value;
	88	#endif
	89	value -= (unsigned long int)(location) + 4;
f6b165c6 MS	90	location[0] = (location[0] & 0xFFFF0000) \|
	91	(value >> 16);
	92	location[1] = (location[1] & 0xFFFF0000) \|
	93	(value & 0xFFFF);
	94	pr_debug("R_MICROBLAZE_64_PCREL (%08lx)\n",
	95	value);
	96	break;
	97
fadf2e60 JW	98	case R_MICROBLAZE_32_PCREL_LO:
	99	pr_debug("R_MICROBLAZE_32_PCREL_LO\n");
	100	break;
	101
679711b8	102	case R_MICROBLAZE_64_NONE:
f5b778be	103	pr_debug("R_MICROBLAZE_64_NONE\n");
679711b8 MS	104	break;
679711b8 MS	105
f6b165c6 MS	106	case R_MICROBLAZE_NONE:
	107	pr_debug("R_MICROBLAZE_NONE\n");
	108	break;
	109
	110	default:
6bd55f0b	111	pr_err("module %s: Unknown relocation: %u\n",
f6b165c6	112	module->name,
fadf2e60	113	ELF32_R_TYPE(rela[i].r_info));
f6b165c6 MS	114	return -ENOEXEC;
	115	}
	116	}
	117	return 0;
	118	}
	119
	120	int module_finalize(const Elf32_Ehdr hdr, const Elf_Shdr sechdrs,
	121	struct module *module)
	122	{
a5e48b88	123	flush_dcache();
f6b165c6 MS	124	return 0;
f6b165c6 MS	125	}