2 * Copyright (C) 2004, 2005 MIPS Technologies, Inc. All rights reserved.
4 * This program is free software; you can distribute it and/or modify it
5 * under the terms of the GNU General Public License (Version 2) as
6 * published by the Free Software Foundation.
8 * This program is distributed in the hope it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * You should have received a copy of the GNU General Public License along
14 * with this program; if not, write to the Free Software Foundation, Inc.,
15 * 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
21 * Provides support for loading a MIPS SP program on VPE1.
22 * The SP enviroment is rather simple, no tlb's. It needs to be relocatable
23 * (or partially linked). You should initialise your stack in the startup
24 * code. This loader looks for the symbol __start and sets up
25 * execution to resume from there. The MIPS SDE kit contains suitable examples.
27 * To load and run, simply cat a SP 'program file' to /dev/vpe1.
28 * i.e cat spapp >/dev/vpe1.
30 #include <linux/kernel.h>
31 #include <linux/device.h>
32 #include <linux/module.h>
34 #include <linux/init.h>
35 #include <asm/uaccess.h>
36 #include <linux/slab.h>
37 #include <linux/list.h>
38 #include <linux/vmalloc.h>
39 #include <linux/elf.h>
40 #include <linux/seq_file.h>
41 #include <linux/syscalls.h>
42 #include <linux/moduleloader.h>
43 #include <linux/interrupt.h>
44 #include <linux/poll.h>
45 #include <linux/bootmem.h>
46 #include <asm/mipsregs.h>
47 #include <asm/mipsmtregs.h>
48 #include <asm/cacheflush.h>
49 #include <asm/atomic.h>
51 #include <asm/mips_mt.h>
52 #include <asm/processor.h>
53 #include <asm/system.h>
57 typedef void *vpe_handle
;
59 #ifndef ARCH_SHF_SMALL
60 #define ARCH_SHF_SMALL 0
63 /* If this is set, the section belongs in the init part of the module */
64 #define INIT_OFFSET_MASK (1UL << (BITS_PER_LONG-1))
67 * The number of TCs and VPEs physically available on the core
69 static int hw_tcs
, hw_vpes
;
70 static char module_name
[] = "vpe";
72 static const int minor
= 1; /* fixed for now */
74 #ifdef CONFIG_MIPS_APSP_KSPD
75 static struct kspd_notifications kspd_events
;
76 static int kspd_events_reqd
= 0;
79 /* grab the likely amount of memory we will need. */
80 #ifdef CONFIG_MIPS_VPE_LOADER_TOM
81 #define P_SIZE (2 * 1024 * 1024)
83 /* add an overhead to the max kmalloc size for non-striped symbols/etc */
84 #define P_SIZE (256 * 1024)
87 extern unsigned long physical_memsize
;
90 #define VPE_PATH_MAX 256
106 enum vpe_state state
;
108 /* (device) minor associated with this vpe */
111 /* elfloader stuff */
116 unsigned int uid
, gid
;
117 char cwd
[VPE_PATH_MAX
];
119 unsigned long __start
;
121 /* tc's associated with this vpe */
124 /* The list of vpe's */
125 struct list_head list
;
127 /* shared symbol address */
130 /* the list of who wants to know when something major happens */
131 struct list_head notify
;
140 struct vpe
*pvpe
; /* parent VPE */
141 struct list_head tc
; /* The list of TC's with this VPE */
142 struct list_head list
; /* The global list of tc's */
146 /* Virtual processing elements */
147 struct list_head vpe_list
;
149 /* Thread contexts */
150 struct list_head tc_list
;
152 .vpe_list
= LIST_HEAD_INIT(vpecontrol
.vpe_list
),
153 .tc_list
= LIST_HEAD_INIT(vpecontrol
.tc_list
)
156 static void release_progmem(void *ptr
);
157 extern void save_gp_address(unsigned int secbase
, unsigned int rel
);
159 /* get the vpe associated with this minor */
160 struct vpe
*get_vpe(int minor
)
167 list_for_each_entry(v
, &vpecontrol
.vpe_list
, list
) {
168 if (v
->minor
== minor
)
175 /* get the vpe associated with this minor */
176 struct tc
*get_tc(int index
)
180 list_for_each_entry(t
, &vpecontrol
.tc_list
, list
) {
181 if (t
->index
== index
)
188 struct tc
*get_tc_unused(void)
192 list_for_each_entry(t
, &vpecontrol
.tc_list
, list
) {
193 if (t
->state
== TC_STATE_UNUSED
)
200 /* allocate a vpe and associate it with this minor (or index) */
201 struct vpe
*alloc_vpe(int minor
)
205 if ((v
= kzalloc(sizeof(struct vpe
), GFP_KERNEL
)) == NULL
) {
209 INIT_LIST_HEAD(&v
->tc
);
210 list_add_tail(&v
->list
, &vpecontrol
.vpe_list
);
212 INIT_LIST_HEAD(&v
->notify
);
217 /* allocate a tc. At startup only tc0 is running, all other can be halted. */
218 struct tc
*alloc_tc(int index
)
222 if ((tc
= kzalloc(sizeof(struct tc
), GFP_KERNEL
)) == NULL
)
225 INIT_LIST_HEAD(&tc
->tc
);
227 list_add_tail(&tc
->list
, &vpecontrol
.tc_list
);
233 /* clean up and free everything */
234 void release_vpe(struct vpe
*v
)
242 void dump_mtregs(void)
246 val
= read_c0_config3();
247 printk("config3 0x%lx MT %ld\n", val
,
248 (val
& CONFIG3_MT
) >> CONFIG3_MT_SHIFT
);
250 val
= read_c0_mvpcontrol();
251 printk("MVPControl 0x%lx, STLB %ld VPC %ld EVP %ld\n", val
,
252 (val
& MVPCONTROL_STLB
) >> MVPCONTROL_STLB_SHIFT
,
253 (val
& MVPCONTROL_VPC
) >> MVPCONTROL_VPC_SHIFT
,
254 (val
& MVPCONTROL_EVP
));
256 val
= read_c0_mvpconf0();
257 printk("mvpconf0 0x%lx, PVPE %ld PTC %ld M %ld\n", val
,
258 (val
& MVPCONF0_PVPE
) >> MVPCONF0_PVPE_SHIFT
,
259 val
& MVPCONF0_PTC
, (val
& MVPCONF0_M
) >> MVPCONF0_M_SHIFT
);
262 /* Find some VPE program space */
263 static void *alloc_progmem(unsigned long len
)
267 #ifdef CONFIG_MIPS_VPE_LOADER_TOM
269 * This means you must tell Linux to use less memory than you
270 * physically have, for example by passing a mem= boot argument.
272 addr
= pfn_to_kaddr(max_low_pfn
);
273 memset(addr
, 0, len
);
275 /* simple grab some mem for now */
276 addr
= kzalloc(len
, GFP_KERNEL
);
282 static void release_progmem(void *ptr
)
284 #ifndef CONFIG_MIPS_VPE_LOADER_TOM
289 /* Update size with this section: return offset. */
290 static long get_offset(unsigned long *size
, Elf_Shdr
* sechdr
)
294 ret
= ALIGN(*size
, sechdr
->sh_addralign
? : 1);
295 *size
= ret
+ sechdr
->sh_size
;
299 /* Lay out the SHF_ALLOC sections in a way not dissimilar to how ld
300 might -- code, read-only data, read-write data, small data. Tally
301 sizes, and place the offsets into sh_entsize fields: high bit means it
303 static void layout_sections(struct module
*mod
, const Elf_Ehdr
* hdr
,
304 Elf_Shdr
* sechdrs
, const char *secstrings
)
306 static unsigned long const masks
[][2] = {
307 /* NOTE: all executable code must be the first section
308 * in this array; otherwise modify the text_size
309 * finder in the two loops below */
310 {SHF_EXECINSTR
| SHF_ALLOC
, ARCH_SHF_SMALL
},
311 {SHF_ALLOC
, SHF_WRITE
| ARCH_SHF_SMALL
},
312 {SHF_WRITE
| SHF_ALLOC
, ARCH_SHF_SMALL
},
313 {ARCH_SHF_SMALL
| SHF_ALLOC
, 0}
317 for (i
= 0; i
< hdr
->e_shnum
; i
++)
318 sechdrs
[i
].sh_entsize
= ~0UL;
320 for (m
= 0; m
< ARRAY_SIZE(masks
); ++m
) {
321 for (i
= 0; i
< hdr
->e_shnum
; ++i
) {
322 Elf_Shdr
*s
= &sechdrs
[i
];
324 // || strncmp(secstrings + s->sh_name, ".init", 5) == 0)
325 if ((s
->sh_flags
& masks
[m
][0]) != masks
[m
][0]
326 || (s
->sh_flags
& masks
[m
][1])
327 || s
->sh_entsize
!= ~0UL)
329 s
->sh_entsize
= get_offset(&mod
->core_size
, s
);
333 mod
->core_text_size
= mod
->core_size
;
339 /* from module-elf32.c, but subverted a little */
342 struct mips_hi16
*next
;
347 static struct mips_hi16
*mips_hi16_list
;
348 static unsigned int gp_offs
, gp_addr
;
350 static int apply_r_mips_none(struct module
*me
, uint32_t *location
,
356 static int apply_r_mips_gprel16(struct module
*me
, uint32_t *location
,
361 if( !(*location
& 0xffff) ) {
362 rel
= (int)v
- gp_addr
;
365 /* .sbss + gp(relative) + offset */
367 rel
= (int)(short)((int)v
+ gp_offs
+
368 (int)(short)(*location
& 0xffff) - gp_addr
);
371 if( (rel
> 32768) || (rel
< -32768) ) {
372 printk(KERN_DEBUG
"VPE loader: apply_r_mips_gprel16: "
373 "relative address 0x%x out of range of gp register\n",
378 *location
= (*location
& 0xffff0000) | (rel
& 0xffff);
383 static int apply_r_mips_pc16(struct module
*me
, uint32_t *location
,
387 rel
= (((unsigned int)v
- (unsigned int)location
));
388 rel
>>= 2; // because the offset is in _instructions_ not bytes.
389 rel
-= 1; // and one instruction less due to the branch delay slot.
391 if( (rel
> 32768) || (rel
< -32768) ) {
392 printk(KERN_DEBUG
"VPE loader: "
393 "apply_r_mips_pc16: relative address out of range 0x%x\n", rel
);
397 *location
= (*location
& 0xffff0000) | (rel
& 0xffff);
402 static int apply_r_mips_32(struct module
*me
, uint32_t *location
,
410 static int apply_r_mips_26(struct module
*me
, uint32_t *location
,
414 printk(KERN_DEBUG
"VPE loader: apply_r_mips_26 "
415 " unaligned relocation\n");
420 * Not desperately convinced this is a good check of an overflow condition
421 * anyway. But it gets in the way of handling undefined weak symbols which
422 * we want to set to zero.
423 * if ((v & 0xf0000000) != (((unsigned long)location + 4) & 0xf0000000)) {
425 * "module %s: relocation overflow\n",
431 *location
= (*location
& ~0x03ffffff) |
432 ((*location
+ (v
>> 2)) & 0x03ffffff);
436 static int apply_r_mips_hi16(struct module
*me
, uint32_t *location
,
442 * We cannot relocate this one now because we don't know the value of
443 * the carry we need to add. Save the information, and let LO16 do the
446 n
= kmalloc(sizeof *n
, GFP_KERNEL
);
452 n
->next
= mips_hi16_list
;
458 static int apply_r_mips_lo16(struct module
*me
, uint32_t *location
,
461 unsigned long insnlo
= *location
;
462 Elf32_Addr val
, vallo
;
464 /* Sign extend the addend we extract from the lo insn. */
465 vallo
= ((insnlo
& 0xffff) ^ 0x8000) - 0x8000;
467 if (mips_hi16_list
!= NULL
) {
472 struct mips_hi16
*next
;
476 * The value for the HI16 had best be the same.
479 printk(KERN_DEBUG
"VPE loader: "
480 "apply_r_mips_lo16/hi16: \t"
481 "inconsistent value information\n");
486 * Do the HI16 relocation. Note that we actually don't
487 * need to know anything about the LO16 itself, except
488 * where to find the low 16 bits of the addend needed
492 val
= ((insn
& 0xffff) << 16) + vallo
;
496 * Account for the sign extension that will happen in
499 val
= ((val
>> 16) + ((val
& 0x8000) != 0)) & 0xffff;
501 insn
= (insn
& ~0xffff) | val
;
509 mips_hi16_list
= NULL
;
513 * Ok, we're done with the HI16 relocs. Now deal with the LO16.
516 insnlo
= (insnlo
& ~0xffff) | (val
& 0xffff);
522 static int (*reloc_handlers
[]) (struct module
*me
, uint32_t *location
,
524 [R_MIPS_NONE
] = apply_r_mips_none
,
525 [R_MIPS_32
] = apply_r_mips_32
,
526 [R_MIPS_26
] = apply_r_mips_26
,
527 [R_MIPS_HI16
] = apply_r_mips_hi16
,
528 [R_MIPS_LO16
] = apply_r_mips_lo16
,
529 [R_MIPS_GPREL16
] = apply_r_mips_gprel16
,
530 [R_MIPS_PC16
] = apply_r_mips_pc16
533 static char *rstrs
[] = {
534 [R_MIPS_NONE
] = "MIPS_NONE",
535 [R_MIPS_32
] = "MIPS_32",
536 [R_MIPS_26
] = "MIPS_26",
537 [R_MIPS_HI16
] = "MIPS_HI16",
538 [R_MIPS_LO16
] = "MIPS_LO16",
539 [R_MIPS_GPREL16
] = "MIPS_GPREL16",
540 [R_MIPS_PC16
] = "MIPS_PC16"
543 int apply_relocations(Elf32_Shdr
*sechdrs
,
545 unsigned int symindex
,
549 Elf32_Rel
*rel
= (void *) sechdrs
[relsec
].sh_addr
;
556 for (i
= 0; i
< sechdrs
[relsec
].sh_size
/ sizeof(*rel
); i
++) {
557 Elf32_Word r_info
= rel
[i
].r_info
;
559 /* This is where to make the change */
560 location
= (void *)sechdrs
[sechdrs
[relsec
].sh_info
].sh_addr
562 /* This is the symbol it is referring to */
563 sym
= (Elf32_Sym
*)sechdrs
[symindex
].sh_addr
564 + ELF32_R_SYM(r_info
);
566 if (!sym
->st_value
) {
567 printk(KERN_DEBUG
"%s: undefined weak symbol %s\n",
568 me
->name
, strtab
+ sym
->st_name
);
569 /* just print the warning, dont barf */
574 res
= reloc_handlers
[ELF32_R_TYPE(r_info
)](me
, location
, v
);
576 char *r
= rstrs
[ELF32_R_TYPE(r_info
)];
577 printk(KERN_WARNING
"VPE loader: .text+0x%x "
578 "relocation type %s for symbol \"%s\" failed\n",
579 rel
[i
].r_offset
, r
? r
: "UNKNOWN",
580 strtab
+ sym
->st_name
);
588 void save_gp_address(unsigned int secbase
, unsigned int rel
)
590 gp_addr
= secbase
+ rel
;
591 gp_offs
= gp_addr
- (secbase
& 0xffff0000);
593 /* end module-elf32.c */
597 /* Change all symbols so that sh_value encodes the pointer directly. */
598 static void simplify_symbols(Elf_Shdr
* sechdrs
,
599 unsigned int symindex
,
601 const char *secstrings
,
602 unsigned int nsecs
, struct module
*mod
)
604 Elf_Sym
*sym
= (void *)sechdrs
[symindex
].sh_addr
;
605 unsigned long secbase
, bssbase
= 0;
606 unsigned int i
, n
= sechdrs
[symindex
].sh_size
/ sizeof(Elf_Sym
);
609 /* find the .bss section for COMMON symbols */
610 for (i
= 0; i
< nsecs
; i
++) {
611 if (strncmp(secstrings
+ sechdrs
[i
].sh_name
, ".bss", 4) == 0) {
612 bssbase
= sechdrs
[i
].sh_addr
;
617 for (i
= 1; i
< n
; i
++) {
618 switch (sym
[i
].st_shndx
) {
620 /* Allocate space for the symbol in the .bss section.
621 st_value is currently size.
622 We want it to have the address of the symbol. */
624 size
= sym
[i
].st_value
;
625 sym
[i
].st_value
= bssbase
;
631 /* Don't need to do anything */
638 case SHN_MIPS_SCOMMON
:
639 printk(KERN_DEBUG
"simplify_symbols: ignoring SHN_MIPS_SCOMMON "
640 "symbol <%s> st_shndx %d\n", strtab
+ sym
[i
].st_name
,
646 secbase
= sechdrs
[sym
[i
].st_shndx
].sh_addr
;
648 if (strncmp(strtab
+ sym
[i
].st_name
, "_gp", 3) == 0) {
649 save_gp_address(secbase
, sym
[i
].st_value
);
652 sym
[i
].st_value
+= secbase
;
658 #ifdef DEBUG_ELFLOADER
659 static void dump_elfsymbols(Elf_Shdr
* sechdrs
, unsigned int symindex
,
660 const char *strtab
, struct module
*mod
)
662 Elf_Sym
*sym
= (void *)sechdrs
[symindex
].sh_addr
;
663 unsigned int i
, n
= sechdrs
[symindex
].sh_size
/ sizeof(Elf_Sym
);
665 printk(KERN_DEBUG
"dump_elfsymbols: n %d\n", n
);
666 for (i
= 1; i
< n
; i
++) {
667 printk(KERN_DEBUG
" i %d name <%s> 0x%x\n", i
,
668 strtab
+ sym
[i
].st_name
, sym
[i
].st_value
);
673 /* We are prepared so configure and start the VPE... */
674 static int vpe_run(struct vpe
* v
)
676 unsigned long flags
, val
, dmt_flag
;
677 struct vpe_notifications
*n
;
678 unsigned int vpeflags
;
681 /* check we are the Master VPE */
682 local_irq_save(flags
);
683 val
= read_c0_vpeconf0();
684 if (!(val
& VPECONF0_MVP
)) {
686 "VPE loader: only Master VPE's are allowed to configure MT\n");
687 local_irq_restore(flags
);
695 if (!list_empty(&v
->tc
)) {
696 if ((t
= list_entry(v
->tc
.next
, struct tc
, tc
)) == NULL
) {
699 local_irq_restore(flags
);
702 "VPE loader: TC %d is already in use.\n",
709 local_irq_restore(flags
);
712 "VPE loader: No TC's associated with VPE %d\n",
718 /* Put MVPE's into 'configuration state' */
719 set_c0_mvpcontrol(MVPCONTROL_VPC
);
723 /* should check it is halted, and not activated */
724 if ((read_tc_c0_tcstatus() & TCSTATUS_A
) || !(read_tc_c0_tchalt() & TCHALT_H
)) {
727 local_irq_restore(flags
);
729 printk(KERN_WARNING
"VPE loader: TC %d is already active!\n",
735 /* Write the address we want it to start running from in the TCPC register. */
736 write_tc_c0_tcrestart((unsigned long)v
->__start
);
737 write_tc_c0_tccontext((unsigned long)0);
740 * Mark the TC as activated, not interrupt exempt and not dynamically
743 val
= read_tc_c0_tcstatus();
744 val
= (val
& ~(TCSTATUS_DA
| TCSTATUS_IXMT
)) | TCSTATUS_A
;
745 write_tc_c0_tcstatus(val
);
747 write_tc_c0_tchalt(read_tc_c0_tchalt() & ~TCHALT_H
);
750 * The sde-kit passes 'memsize' to __start in $a3, so set something
751 * here... Or set $a3 to zero and define DFLT_STACK_SIZE and
752 * DFLT_HEAP_SIZE when you compile your program
755 mttgpr(7, physical_memsize
);
759 * bind the TC to VPE 1 as late as possible so we only have the final
760 * VPE registers to set up, and so an EJTAG probe can trigger on it
762 write_tc_c0_tcbind((read_tc_c0_tcbind() & ~TCBIND_CURVPE
) | 1);
764 write_vpe_c0_vpeconf0(read_vpe_c0_vpeconf0() & ~(VPECONF0_VPA
));
766 back_to_back_c0_hazard();
768 /* Set up the XTC bit in vpeconf0 to point at our tc */
769 write_vpe_c0_vpeconf0( (read_vpe_c0_vpeconf0() & ~(VPECONF0_XTC
))
770 | (t
->index
<< VPECONF0_XTC_SHIFT
));
772 back_to_back_c0_hazard();
774 /* enable this VPE */
775 write_vpe_c0_vpeconf0(read_vpe_c0_vpeconf0() | VPECONF0_VPA
);
777 /* clear out any left overs from a previous program */
778 write_vpe_c0_status(0);
779 write_vpe_c0_cause(0);
781 /* take system out of configuration state */
782 clear_c0_mvpcontrol(MVPCONTROL_VPC
);
785 * SMTC/SMVP kernels manage VPE enable independently,
786 * but uniprocessor kernels need to turn it on, even
787 * if that wasn't the pre-dvpe() state.
795 local_irq_restore(flags
);
797 list_for_each_entry(n
, &v
->notify
, list
)
803 static int find_vpe_symbols(struct vpe
* v
, Elf_Shdr
* sechdrs
,
804 unsigned int symindex
, const char *strtab
,
807 Elf_Sym
*sym
= (void *)sechdrs
[symindex
].sh_addr
;
808 unsigned int i
, n
= sechdrs
[symindex
].sh_size
/ sizeof(Elf_Sym
);
810 for (i
= 1; i
< n
; i
++) {
811 if (strcmp(strtab
+ sym
[i
].st_name
, "__start") == 0) {
812 v
->__start
= sym
[i
].st_value
;
815 if (strcmp(strtab
+ sym
[i
].st_name
, "vpe_shared") == 0) {
816 v
->shared_ptr
= (void *)sym
[i
].st_value
;
820 if ( (v
->__start
== 0) || (v
->shared_ptr
== NULL
))
827 * Allocates a VPE with some program code space(the load address), copies the
828 * contents of the program (p)buffer performing relocatations/etc, free's it
831 static int vpe_elfload(struct vpe
* v
)
836 char *secstrings
, *strtab
= NULL
;
837 unsigned int len
, i
, symindex
= 0, strindex
= 0, relocate
= 0;
838 struct module mod
; // so we can re-use the relocations code
840 memset(&mod
, 0, sizeof(struct module
));
841 strcpy(mod
.name
, "VPE loader");
843 hdr
= (Elf_Ehdr
*) v
->pbuffer
;
846 /* Sanity checks against insmoding binaries or wrong arch,
848 if (memcmp(hdr
->e_ident
, ELFMAG
, SELFMAG
) != 0
849 || (hdr
->e_type
!= ET_REL
&& hdr
->e_type
!= ET_EXEC
)
850 || !elf_check_arch(hdr
)
851 || hdr
->e_shentsize
!= sizeof(*sechdrs
)) {
853 "VPE loader: program wrong arch or weird elf version\n");
858 if (hdr
->e_type
== ET_REL
)
861 if (len
< hdr
->e_shoff
+ hdr
->e_shnum
* sizeof(Elf_Shdr
)) {
862 printk(KERN_ERR
"VPE loader: program length %u truncated\n",
868 /* Convenience variables */
869 sechdrs
= (void *)hdr
+ hdr
->e_shoff
;
870 secstrings
= (void *)hdr
+ sechdrs
[hdr
->e_shstrndx
].sh_offset
;
871 sechdrs
[0].sh_addr
= 0;
873 /* And these should exist, but gcc whinges if we don't init them */
874 symindex
= strindex
= 0;
877 for (i
= 1; i
< hdr
->e_shnum
; i
++) {
878 if (sechdrs
[i
].sh_type
!= SHT_NOBITS
879 && len
< sechdrs
[i
].sh_offset
+ sechdrs
[i
].sh_size
) {
880 printk(KERN_ERR
"VPE program length %u truncated\n",
885 /* Mark all sections sh_addr with their address in the
887 sechdrs
[i
].sh_addr
= (size_t) hdr
+ sechdrs
[i
].sh_offset
;
889 /* Internal symbols and strings. */
890 if (sechdrs
[i
].sh_type
== SHT_SYMTAB
) {
892 strindex
= sechdrs
[i
].sh_link
;
893 strtab
= (char *)hdr
+ sechdrs
[strindex
].sh_offset
;
896 layout_sections(&mod
, hdr
, sechdrs
, secstrings
);
899 v
->load_addr
= alloc_progmem(mod
.core_size
);
903 pr_info("VPE loader: loading to %p\n", v
->load_addr
);
906 for (i
= 0; i
< hdr
->e_shnum
; i
++) {
909 if (!(sechdrs
[i
].sh_flags
& SHF_ALLOC
))
912 dest
= v
->load_addr
+ sechdrs
[i
].sh_entsize
;
914 if (sechdrs
[i
].sh_type
!= SHT_NOBITS
)
915 memcpy(dest
, (void *)sechdrs
[i
].sh_addr
,
917 /* Update sh_addr to point to copy in image. */
918 sechdrs
[i
].sh_addr
= (unsigned long)dest
;
920 printk(KERN_DEBUG
" section sh_name %s sh_addr 0x%x\n",
921 secstrings
+ sechdrs
[i
].sh_name
, sechdrs
[i
].sh_addr
);
924 /* Fix up syms, so that st_value is a pointer to location. */
925 simplify_symbols(sechdrs
, symindex
, strtab
, secstrings
,
928 /* Now do relocations. */
929 for (i
= 1; i
< hdr
->e_shnum
; i
++) {
930 const char *strtab
= (char *)sechdrs
[strindex
].sh_addr
;
931 unsigned int info
= sechdrs
[i
].sh_info
;
933 /* Not a valid relocation section? */
934 if (info
>= hdr
->e_shnum
)
937 /* Don't bother with non-allocated sections */
938 if (!(sechdrs
[info
].sh_flags
& SHF_ALLOC
))
941 if (sechdrs
[i
].sh_type
== SHT_REL
)
942 err
= apply_relocations(sechdrs
, strtab
, symindex
, i
,
944 else if (sechdrs
[i
].sh_type
== SHT_RELA
)
945 err
= apply_relocate_add(sechdrs
, strtab
, symindex
, i
,
952 struct elf_phdr
*phdr
= (struct elf_phdr
*) ((char *)hdr
+ hdr
->e_phoff
);
954 for (i
= 0; i
< hdr
->e_phnum
; i
++) {
955 if (phdr
->p_type
== PT_LOAD
) {
956 memcpy((void *)phdr
->p_paddr
,
957 (char *)hdr
+ phdr
->p_offset
,
959 memset((void *)phdr
->p_paddr
+ phdr
->p_filesz
,
960 0, phdr
->p_memsz
- phdr
->p_filesz
);
965 for (i
= 0; i
< hdr
->e_shnum
; i
++) {
966 /* Internal symbols and strings. */
967 if (sechdrs
[i
].sh_type
== SHT_SYMTAB
) {
969 strindex
= sechdrs
[i
].sh_link
;
970 strtab
= (char *)hdr
+ sechdrs
[strindex
].sh_offset
;
972 /* mark the symtab's address for when we try to find the
974 sechdrs
[i
].sh_addr
= (size_t) hdr
+ sechdrs
[i
].sh_offset
;
979 /* make sure it's physically written out */
980 flush_icache_range((unsigned long)v
->load_addr
,
981 (unsigned long)v
->load_addr
+ v
->len
);
983 if ((find_vpe_symbols(v
, sechdrs
, symindex
, strtab
, &mod
)) < 0) {
984 if (v
->__start
== 0) {
985 printk(KERN_WARNING
"VPE loader: program does not contain "
986 "a __start symbol\n");
990 if (v
->shared_ptr
== NULL
)
991 printk(KERN_WARNING
"VPE loader: "
992 "program does not contain vpe_shared symbol.\n"
993 " Unable to use AMVP (AP/SP) facilities.\n");
996 printk(" elf loaded\n");
1000 static void cleanup_tc(struct tc
*tc
)
1002 unsigned long flags
;
1003 unsigned int mtflags
, vpflags
;
1006 local_irq_save(flags
);
1009 /* Put MVPE's into 'configuration state' */
1010 set_c0_mvpcontrol(MVPCONTROL_VPC
);
1013 tmp
= read_tc_c0_tcstatus();
1015 /* mark not allocated and not dynamically allocatable */
1016 tmp
&= ~(TCSTATUS_A
| TCSTATUS_DA
);
1017 tmp
|= TCSTATUS_IXMT
; /* interrupt exempt */
1018 write_tc_c0_tcstatus(tmp
);
1020 write_tc_c0_tchalt(TCHALT_H
);
1023 /* bind it to anything other than VPE1 */
1024 // write_tc_c0_tcbind(read_tc_c0_tcbind() & ~TCBIND_CURVPE); // | TCBIND_CURVPE
1026 clear_c0_mvpcontrol(MVPCONTROL_VPC
);
1029 local_irq_restore(flags
);
1032 static int getcwd(char *buff
, int size
)
1034 mm_segment_t old_fs
;
1040 ret
= sys_getcwd(buff
, size
);
1047 /* checks VPE is unused and gets ready to load program */
1048 static int vpe_open(struct inode
*inode
, struct file
*filp
)
1050 enum vpe_state state
;
1051 struct vpe_notifications
*not;
1055 if (minor
!= iminor(inode
)) {
1056 /* assume only 1 device at the moment. */
1057 printk(KERN_WARNING
"VPE loader: only vpe1 is supported\n");
1061 if ((v
= get_vpe(tclimit
)) == NULL
) {
1062 printk(KERN_WARNING
"VPE loader: unable to get vpe\n");
1066 state
= xchg(&v
->state
, VPE_STATE_INUSE
);
1067 if (state
!= VPE_STATE_UNUSED
) {
1068 printk(KERN_DEBUG
"VPE loader: tc in use dumping regs\n");
1070 list_for_each_entry(not, &v
->notify
, list
) {
1074 release_progmem(v
->load_addr
);
1075 cleanup_tc(get_tc(tclimit
));
1078 /* this of-course trashes what was there before... */
1079 v
->pbuffer
= vmalloc(P_SIZE
);
1081 v
->load_addr
= NULL
;
1084 v
->uid
= filp
->f_uid
;
1085 v
->gid
= filp
->f_gid
;
1087 #ifdef CONFIG_MIPS_APSP_KSPD
1088 /* get kspd to tell us when a syscall_exit happens */
1089 if (!kspd_events_reqd
) {
1090 kspd_notify(&kspd_events
);
1096 ret
= getcwd(v
->cwd
, VPE_PATH_MAX
);
1098 printk(KERN_WARNING
"VPE loader: open, getcwd returned %d\n", ret
);
1100 v
->shared_ptr
= NULL
;
1106 static int vpe_release(struct inode
*inode
, struct file
*filp
)
1112 v
= get_vpe(tclimit
);
1116 hdr
= (Elf_Ehdr
*) v
->pbuffer
;
1117 if (memcmp(hdr
->e_ident
, ELFMAG
, SELFMAG
) == 0) {
1118 if (vpe_elfload(v
) >= 0) {
1121 printk(KERN_WARNING
"VPE loader: ELF load failed.\n");
1125 printk(KERN_WARNING
"VPE loader: only elf files are supported\n");
1129 /* It's good to be able to run the SP and if it chokes have a look at
1130 the /dev/rt?. But if we reset the pointer to the shared struct we
1131 loose what has happened. So perhaps if garbage is sent to the vpe
1132 device, use it as a trigger for the reset. Hopefully a nice
1133 executable will be along shortly. */
1135 v
->shared_ptr
= NULL
;
1137 // cleanup any temp buffers
1144 static ssize_t
vpe_write(struct file
*file
, const char __user
* buffer
,
1145 size_t count
, loff_t
* ppos
)
1150 if (iminor(file
->f_path
.dentry
->d_inode
) != minor
)
1153 v
= get_vpe(tclimit
);
1157 if (v
->pbuffer
== NULL
) {
1158 printk(KERN_ERR
"VPE loader: no buffer for program\n");
1162 if ((count
+ v
->len
) > v
->plen
) {
1164 "VPE loader: elf size too big. Perhaps strip uneeded symbols\n");
1168 count
-= copy_from_user(v
->pbuffer
+ v
->len
, buffer
, count
);
1176 static const struct file_operations vpe_fops
= {
1177 .owner
= THIS_MODULE
,
1179 .release
= vpe_release
,
1183 /* module wrapper entry points */
1185 vpe_handle
vpe_alloc(void)
1191 for (i
= 1; i
< MAX_VPES
; i
++) {
1192 if ((v
= get_vpe(i
)) != NULL
) {
1193 v
->state
= VPE_STATE_INUSE
;
1200 EXPORT_SYMBOL(vpe_alloc
);
1202 /* start running from here */
1203 int vpe_start(vpe_handle vpe
, unsigned long start
)
1205 struct vpe
*v
= vpe
;
1211 EXPORT_SYMBOL(vpe_start
);
1213 /* halt it for now */
1214 int vpe_stop(vpe_handle vpe
)
1216 struct vpe
*v
= vpe
;
1218 unsigned int evpe_flags
;
1220 evpe_flags
= dvpe();
1222 if ((t
= list_entry(v
->tc
.next
, struct tc
, tc
)) != NULL
) {
1225 write_vpe_c0_vpeconf0(read_vpe_c0_vpeconf0() & ~VPECONF0_VPA
);
1233 EXPORT_SYMBOL(vpe_stop
);
1235 /* I've done with it thank you */
1236 int vpe_free(vpe_handle vpe
)
1238 struct vpe
*v
= vpe
;
1240 unsigned int evpe_flags
;
1242 if ((t
= list_entry(v
->tc
.next
, struct tc
, tc
)) == NULL
) {
1246 evpe_flags
= dvpe();
1248 /* Put MVPE's into 'configuration state' */
1249 set_c0_mvpcontrol(MVPCONTROL_VPC
);
1252 write_vpe_c0_vpeconf0(read_vpe_c0_vpeconf0() & ~VPECONF0_VPA
);
1255 write_tc_c0_tchalt(TCHALT_H
);
1258 /* mark the TC unallocated */
1259 write_tc_c0_tcstatus(read_tc_c0_tcstatus() & ~TCSTATUS_A
);
1261 v
->state
= VPE_STATE_UNUSED
;
1263 clear_c0_mvpcontrol(MVPCONTROL_VPC
);
1269 EXPORT_SYMBOL(vpe_free
);
1271 void *vpe_get_shared(int index
)
1275 if ((v
= get_vpe(index
)) == NULL
)
1278 return v
->shared_ptr
;
1281 EXPORT_SYMBOL(vpe_get_shared
);
1283 int vpe_getuid(int index
)
1287 if ((v
= get_vpe(index
)) == NULL
)
1293 EXPORT_SYMBOL(vpe_getuid
);
1295 int vpe_getgid(int index
)
1299 if ((v
= get_vpe(index
)) == NULL
)
1305 EXPORT_SYMBOL(vpe_getgid
);
1307 int vpe_notify(int index
, struct vpe_notifications
*notify
)
1311 if ((v
= get_vpe(index
)) == NULL
)
1314 list_add(¬ify
->list
, &v
->notify
);
1318 EXPORT_SYMBOL(vpe_notify
);
1320 char *vpe_getcwd(int index
)
1324 if ((v
= get_vpe(index
)) == NULL
)
1330 EXPORT_SYMBOL(vpe_getcwd
);
1332 #ifdef CONFIG_MIPS_APSP_KSPD
1333 static void kspd_sp_exit( int sp_id
)
1335 cleanup_tc(get_tc(sp_id
));
1339 static ssize_t
store_kill(struct device
*dev
, struct device_attribute
*attr
,
1340 const char *buf
, size_t len
)
1342 struct vpe
*vpe
= get_vpe(tclimit
);
1343 struct vpe_notifications
*not;
1345 list_for_each_entry(not, &vpe
->notify
, list
) {
1349 release_progmem(vpe
->load_addr
);
1350 cleanup_tc(get_tc(tclimit
));
1357 static ssize_t
show_ntcs(struct device
*cd
, struct device_attribute
*attr
,
1360 struct vpe
*vpe
= get_vpe(tclimit
);
1362 return sprintf(buf
, "%d\n", vpe
->ntcs
);
1365 static ssize_t
store_ntcs(struct device
*dev
, struct device_attribute
*attr
,
1366 const char *buf
, size_t len
)
1368 struct vpe
*vpe
= get_vpe(tclimit
);
1372 new = simple_strtoul(buf
, &endp
, 0);
1376 if (new == 0 || new > (hw_tcs
- tclimit
))
1387 static struct device_attribute vpe_class_attributes
[] = {
1388 __ATTR(kill
, S_IWUSR
, NULL
, store_kill
),
1389 __ATTR(ntcs
, S_IRUGO
| S_IWUSR
, show_ntcs
, store_ntcs
),
1393 static void vpe_device_release(struct device
*cd
)
1398 struct class vpe_class
= {
1400 .owner
= THIS_MODULE
,
1401 .dev_release
= vpe_device_release
,
1402 .dev_attrs
= vpe_class_attributes
,
1405 struct device vpe_device
;
1407 static int __init
vpe_module_init(void)
1409 unsigned int mtflags
, vpflags
;
1410 unsigned long flags
, val
;
1411 struct vpe
*v
= NULL
;
1415 if (!cpu_has_mipsmt
) {
1416 printk("VPE loader: not a MIPS MT capable processor\n");
1420 if (vpelimit
== 0) {
1421 printk(KERN_WARNING
"No VPEs reserved for AP/SP, not "
1422 "initializing VPE loader.\nPass maxvpes=<n> argument as "
1423 "kernel argument\n");
1429 printk(KERN_WARNING
"No TCs reserved for AP/SP, not "
1430 "initializing VPE loader.\nPass maxtcs=<n> argument as "
1431 "kernel argument\n");
1436 major
= register_chrdev(0, module_name
, &vpe_fops
);
1438 printk("VPE loader: unable to register character device\n");
1442 err
= class_register(&vpe_class
);
1444 printk(KERN_ERR
"vpe_class registration failed\n");
1448 device_initialize(&vpe_device
);
1449 vpe_device
.class = &vpe_class
,
1450 vpe_device
.parent
= NULL
,
1451 strlcpy(vpe_device
.bus_id
, "vpe1", BUS_ID_SIZE
);
1452 vpe_device
.devt
= MKDEV(major
, minor
);
1453 err
= device_add(&vpe_device
);
1455 printk(KERN_ERR
"Adding vpe_device failed\n");
1459 local_irq_save(flags
);
1463 /* Put MVPE's into 'configuration state' */
1464 set_c0_mvpcontrol(MVPCONTROL_VPC
);
1466 /* dump_mtregs(); */
1468 val
= read_c0_mvpconf0();
1469 hw_tcs
= (val
& MVPCONF0_PTC
) + 1;
1470 hw_vpes
= ((val
& MVPCONF0_PVPE
) >> MVPCONF0_PVPE_SHIFT
) + 1;
1472 for (tc
= tclimit
; tc
< hw_tcs
; tc
++) {
1474 * Must re-enable multithreading temporarily or in case we
1475 * reschedule send IPIs or similar we might hang.
1477 clear_c0_mvpcontrol(MVPCONTROL_VPC
);
1480 local_irq_restore(flags
);
1487 local_irq_save(flags
);
1490 set_c0_mvpcontrol(MVPCONTROL_VPC
);
1496 if ((v
= alloc_vpe(tc
)) == NULL
) {
1497 printk(KERN_WARNING
"VPE: unable to allocate VPE\n");
1502 v
->ntcs
= hw_tcs
- tclimit
;
1504 /* add the tc to the list of this vpe's tc's. */
1505 list_add(&t
->tc
, &v
->tc
);
1507 /* deactivate all but vpe0 */
1508 if (tc
>= tclimit
) {
1509 unsigned long tmp
= read_vpe_c0_vpeconf0();
1511 tmp
&= ~VPECONF0_VPA
;
1514 tmp
|= VPECONF0_MVP
;
1515 write_vpe_c0_vpeconf0(tmp
);
1518 /* disable multi-threading with TC's */
1519 write_vpe_c0_vpecontrol(read_vpe_c0_vpecontrol() & ~VPECONTROL_TE
);
1521 if (tc
>= vpelimit
) {
1523 * Set config to be the same as vpe0,
1524 * particularly kseg0 coherency alg
1526 write_vpe_c0_config(read_c0_config());
1531 t
->pvpe
= v
; /* set the parent vpe */
1533 if (tc
>= tclimit
) {
1538 /* Any TC that is bound to VPE0 gets left as is - in case
1539 we are running SMTC on VPE0. A TC that is bound to any
1540 other VPE gets bound to VPE0, ideally I'd like to make
1541 it homeless but it doesn't appear to let me bind a TC
1542 to a non-existent VPE. Which is perfectly reasonable.
1544 The (un)bound state is visible to an EJTAG probe so may
1548 if (((tmp
= read_tc_c0_tcbind()) & TCBIND_CURVPE
)) {
1549 /* tc is bound >vpe0 */
1550 write_tc_c0_tcbind(tmp
& ~TCBIND_CURVPE
);
1552 t
->pvpe
= get_vpe(0); /* set the parent vpe */
1556 write_tc_c0_tchalt(TCHALT_H
);
1559 tmp
= read_tc_c0_tcstatus();
1561 /* mark not activated and not dynamically allocatable */
1562 tmp
&= ~(TCSTATUS_A
| TCSTATUS_DA
);
1563 tmp
|= TCSTATUS_IXMT
; /* interrupt exempt */
1564 write_tc_c0_tcstatus(tmp
);
1569 /* release config state */
1570 clear_c0_mvpcontrol(MVPCONTROL_VPC
);
1574 local_irq_restore(flags
);
1576 #ifdef CONFIG_MIPS_APSP_KSPD
1577 kspd_events
.kspd_sp_exit
= kspd_sp_exit
;
1582 class_unregister(&vpe_class
);
1584 unregister_chrdev(major
, module_name
);
1590 static void __exit
vpe_module_exit(void)
1594 list_for_each_entry_safe(v
, n
, &vpecontrol
.vpe_list
, list
) {
1595 if (v
->state
!= VPE_STATE_UNUSED
) {
1600 device_del(&vpe_device
);
1601 unregister_chrdev(major
, module_name
);
1604 module_init(vpe_module_init
);
1605 module_exit(vpe_module_exit
);
1606 MODULE_DESCRIPTION("MIPS VPE Loader");
1607 MODULE_AUTHOR("Elizabeth Oldham, MIPS Technologies, Inc.");
1608 MODULE_LICENSE("GPL");