1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30#include <linux/kernel.h>
31#include <linux/device.h>
32#include <linux/module.h>
33#include <linux/fs.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/smp_lock.h>
42#include <linux/syscalls.h>
43#include <linux/moduleloader.h>
44#include <linux/interrupt.h>
45#include <linux/poll.h>
46#include <linux/bootmem.h>
47#include <asm/mipsregs.h>
48#include <asm/mipsmtregs.h>
49#include <asm/cacheflush.h>
50#include <asm/atomic.h>
51#include <asm/cpu.h>
52#include <asm/mips_mt.h>
53#include <asm/processor.h>
54#include <asm/system.h>
55#include <asm/vpe.h>
56#include <asm/kspd.h>
57
58typedef void *vpe_handle;
59
60#ifndef ARCH_SHF_SMALL
61#define ARCH_SHF_SMALL 0
62#endif
63
64
65#define INIT_OFFSET_MASK (1UL << (BITS_PER_LONG-1))
66
67
68
69
70static int hw_tcs, hw_vpes;
71static char module_name[] = "vpe";
72static int major;
73static const int minor = 1;
74
75#ifdef CONFIG_MIPS_APSP_KSPD
76static struct kspd_notifications kspd_events;
77static int kspd_events_reqd;
78#endif
79
80
81#ifdef CONFIG_MIPS_VPE_LOADER_TOM
82#define P_SIZE (2 * 1024 * 1024)
83#else
84
85#define P_SIZE (256 * 1024)
86#endif
87
88extern unsigned long physical_memsize;
89
90#define MAX_VPES 16
91#define VPE_PATH_MAX 256
92
93enum vpe_state {
94 VPE_STATE_UNUSED = 0,
95 VPE_STATE_INUSE,
96 VPE_STATE_RUNNING
97};
98
99enum tc_state {
100 TC_STATE_UNUSED = 0,
101 TC_STATE_INUSE,
102 TC_STATE_RUNNING,
103 TC_STATE_DYNAMIC
104};
105
106struct vpe {
107 enum vpe_state state;
108
109
110 int minor;
111
112
113 void *load_addr;
114 unsigned long len;
115 char *pbuffer;
116 unsigned long plen;
117 unsigned int uid, gid;
118 char cwd[VPE_PATH_MAX];
119
120 unsigned long __start;
121
122
123 struct list_head tc;
124
125
126 struct list_head list;
127
128
129 void *shared_ptr;
130
131
132 struct list_head notify;
133
134 unsigned int ntcs;
135};
136
137struct tc {
138 enum tc_state state;
139 int index;
140
141 struct vpe *pvpe;
142 struct list_head tc;
143 struct list_head list;
144};
145
146struct {
147 spinlock_t vpe_list_lock;
148 struct list_head vpe_list;
149 spinlock_t tc_list_lock;
150 struct list_head tc_list;
151} vpecontrol = {
152 .vpe_list_lock = SPIN_LOCK_UNLOCKED,
153 .vpe_list = LIST_HEAD_INIT(vpecontrol.vpe_list),
154 .tc_list_lock = SPIN_LOCK_UNLOCKED,
155 .tc_list = LIST_HEAD_INIT(vpecontrol.tc_list)
156};
157
158static void release_progmem(void *ptr);
159
160
161static struct vpe *get_vpe(int minor)
162{
163 struct vpe *res, *v;
164
165 if (!cpu_has_mipsmt)
166 return NULL;
167
168 res = NULL;
169 spin_lock(&vpecontrol.vpe_list_lock);
170 list_for_each_entry(v, &vpecontrol.vpe_list, list) {
171 if (v->minor == minor) {
172 res = v;
173 break;
174 }
175 }
176 spin_unlock(&vpecontrol.vpe_list_lock);
177
178 return res;
179}
180
181
182static struct tc *get_tc(int index)
183{
184 struct tc *res, *t;
185
186 res = NULL;
187 spin_lock(&vpecontrol.tc_list_lock);
188 list_for_each_entry(t, &vpecontrol.tc_list, list) {
189 if (t->index == index) {
190 res = t;
191 break;
192 }
193 }
194 spin_unlock(&vpecontrol.tc_list_lock);
195
196 return NULL;
197}
198
199
200static struct vpe *alloc_vpe(int minor)
201{
202 struct vpe *v;
203
204 if ((v = kzalloc(sizeof(struct vpe), GFP_KERNEL)) == NULL)
205 return NULL;
206
207 INIT_LIST_HEAD(&v->tc);
208 spin_lock(&vpecontrol.vpe_list_lock);
209 list_add_tail(&v->list, &vpecontrol.vpe_list);
210 spin_unlock(&vpecontrol.vpe_list_lock);
211
212 INIT_LIST_HEAD(&v->notify);
213 v->minor = minor;
214
215 return v;
216}
217
218
219static struct tc *alloc_tc(int index)
220{
221 struct tc *tc;
222
223 if ((tc = kzalloc(sizeof(struct tc), GFP_KERNEL)) == NULL)
224 goto out;
225
226 INIT_LIST_HEAD(&tc->tc);
227 tc->index = index;
228
229 spin_lock(&vpecontrol.tc_list_lock);
230 list_add_tail(&tc->list, &vpecontrol.tc_list);
231 spin_unlock(&vpecontrol.tc_list_lock);
232
233out:
234 return tc;
235}
236
237
238static void release_vpe(struct vpe *v)
239{
240 list_del(&v->list);
241 if (v->load_addr)
242 release_progmem(v);
243 kfree(v);
244}
245
246static void __maybe_unused dump_mtregs(void)
247{
248 unsigned long val;
249
250 val = read_c0_config3();
251 printk("config3 0x%lx MT %ld\n", val,
252 (val & CONFIG3_MT) >> CONFIG3_MT_SHIFT);
253
254 val = read_c0_mvpcontrol();
255 printk("MVPControl 0x%lx, STLB %ld VPC %ld EVP %ld\n", val,
256 (val & MVPCONTROL_STLB) >> MVPCONTROL_STLB_SHIFT,
257 (val & MVPCONTROL_VPC) >> MVPCONTROL_VPC_SHIFT,
258 (val & MVPCONTROL_EVP));
259
260 val = read_c0_mvpconf0();
261 printk("mvpconf0 0x%lx, PVPE %ld PTC %ld M %ld\n", val,
262 (val & MVPCONF0_PVPE) >> MVPCONF0_PVPE_SHIFT,
263 val & MVPCONF0_PTC, (val & MVPCONF0_M) >> MVPCONF0_M_SHIFT);
264}
265
266
267static void *alloc_progmem(unsigned long len)
268{
269 void *addr;
270
271#ifdef CONFIG_MIPS_VPE_LOADER_TOM
272
273
274
275
276 addr = pfn_to_kaddr(max_low_pfn);
277 memset(addr, 0, len);
278#else
279
280 addr = kzalloc(len, GFP_KERNEL);
281#endif
282
283 return addr;
284}
285
286static void release_progmem(void *ptr)
287{
288#ifndef CONFIG_MIPS_VPE_LOADER_TOM
289 kfree(ptr);
290#endif
291}
292
293
294static long get_offset(unsigned long *size, Elf_Shdr * sechdr)
295{
296 long ret;
297
298 ret = ALIGN(*size, sechdr->sh_addralign ? : 1);
299 *size = ret + sechdr->sh_size;
300 return ret;
301}
302
303
304
305
306
307static void layout_sections(struct module *mod, const Elf_Ehdr * hdr,
308 Elf_Shdr * sechdrs, const char *secstrings)
309{
310 static unsigned long const masks[][2] = {
311
312
313
314 {SHF_EXECINSTR | SHF_ALLOC, ARCH_SHF_SMALL},
315 {SHF_ALLOC, SHF_WRITE | ARCH_SHF_SMALL},
316 {SHF_WRITE | SHF_ALLOC, ARCH_SHF_SMALL},
317 {ARCH_SHF_SMALL | SHF_ALLOC, 0}
318 };
319 unsigned int m, i;
320
321 for (i = 0; i < hdr->e_shnum; i++)
322 sechdrs[i].sh_entsize = ~0UL;
323
324 for (m = 0; m < ARRAY_SIZE(masks); ++m) {
325 for (i = 0; i < hdr->e_shnum; ++i) {
326 Elf_Shdr *s = &sechdrs[i];
327
328
329 if ((s->sh_flags & masks[m][0]) != masks[m][0]
330 || (s->sh_flags & masks[m][1])
331 || s->sh_entsize != ~0UL)
332 continue;
333 s->sh_entsize =
334 get_offset((unsigned long *)&mod->core_size, s);
335 }
336
337 if (m == 0)
338 mod->core_text_size = mod->core_size;
339
340 }
341}
342
343
344
345
346struct mips_hi16 {
347 struct mips_hi16 *next;
348 Elf32_Addr *addr;
349 Elf32_Addr value;
350};
351
352static struct mips_hi16 *mips_hi16_list;
353static unsigned int gp_offs, gp_addr;
354
355static int apply_r_mips_none(struct module *me, uint32_t *location,
356 Elf32_Addr v)
357{
358 return 0;
359}
360
361static int apply_r_mips_gprel16(struct module *me, uint32_t *location,
362 Elf32_Addr v)
363{
364 int rel;
365
366 if( !(*location & 0xffff) ) {
367 rel = (int)v - gp_addr;
368 }
369 else {
370
371
372 rel = (int)(short)((int)v + gp_offs +
373 (int)(short)(*location & 0xffff) - gp_addr);
374 }
375
376 if( (rel > 32768) || (rel < -32768) ) {
377 printk(KERN_DEBUG "VPE loader: apply_r_mips_gprel16: "
378 "relative address 0x%x out of range of gp register\n",
379 rel);
380 return -ENOEXEC;
381 }
382
383 *location = (*location & 0xffff0000) | (rel & 0xffff);
384
385 return 0;
386}
387
388static int apply_r_mips_pc16(struct module *me, uint32_t *location,
389 Elf32_Addr v)
390{
391 int rel;
392 rel = (((unsigned int)v - (unsigned int)location));
393 rel >>= 2;
394 rel -= 1;
395
396 if( (rel > 32768) || (rel < -32768) ) {
397 printk(KERN_DEBUG "VPE loader: "
398 "apply_r_mips_pc16: relative address out of range 0x%x\n", rel);
399 return -ENOEXEC;
400 }
401
402 *location = (*location & 0xffff0000) | (rel & 0xffff);
403
404 return 0;
405}
406
407static int apply_r_mips_32(struct module *me, uint32_t *location,
408 Elf32_Addr v)
409{
410 *location += v;
411
412 return 0;
413}
414
415static int apply_r_mips_26(struct module *me, uint32_t *location,
416 Elf32_Addr v)
417{
418 if (v % 4) {
419 printk(KERN_DEBUG "VPE loader: apply_r_mips_26 "
420 " unaligned relocation\n");
421 return -ENOEXEC;
422 }
423
424
425
426
427
428
429
430
431
432
433
434
435
436 *location = (*location & ~0x03ffffff) |
437 ((*location + (v >> 2)) & 0x03ffffff);
438 return 0;
439}
440
441static int apply_r_mips_hi16(struct module *me, uint32_t *location,
442 Elf32_Addr v)
443{
444 struct mips_hi16 *n;
445
446
447
448
449
450
451 n = kmalloc(sizeof *n, GFP_KERNEL);
452 if (!n)
453 return -ENOMEM;
454
455 n->addr = location;
456 n->value = v;
457 n->next = mips_hi16_list;
458 mips_hi16_list = n;
459
460 return 0;
461}
462
463static int apply_r_mips_lo16(struct module *me, uint32_t *location,
464 Elf32_Addr v)
465{
466 unsigned long insnlo = *location;
467 Elf32_Addr val, vallo;
468 struct mips_hi16 *l, *next;
469
470
471 vallo = ((insnlo & 0xffff) ^ 0x8000) - 0x8000;
472
473 if (mips_hi16_list != NULL) {
474
475 l = mips_hi16_list;
476 while (l != NULL) {
477 unsigned long insn;
478
479
480
481
482 if (v != l->value) {
483 printk(KERN_DEBUG "VPE loader: "
484 "apply_r_mips_lo16/hi16: \t"
485 "inconsistent value information\n");
486 goto out_free;
487 }
488
489
490
491
492
493
494
495 insn = *l->addr;
496 val = ((insn & 0xffff) << 16) + vallo;
497 val += v;
498
499
500
501
502
503 val = ((val >> 16) + ((val & 0x8000) != 0)) & 0xffff;
504
505 insn = (insn & ~0xffff) | val;
506 *l->addr = insn;
507
508 next = l->next;
509 kfree(l);
510 l = next;
511 }
512
513 mips_hi16_list = NULL;
514 }
515
516
517
518
519 val = v + vallo;
520 insnlo = (insnlo & ~0xffff) | (val & 0xffff);
521 *location = insnlo;
522
523 return 0;
524
525out_free:
526 while (l != NULL) {
527 next = l->next;
528 kfree(l);
529 l = next;
530 }
531 mips_hi16_list = NULL;
532
533 return -ENOEXEC;
534}
535
536static int (*reloc_handlers[]) (struct module *me, uint32_t *location,
537 Elf32_Addr v) = {
538 [R_MIPS_NONE] = apply_r_mips_none,
539 [R_MIPS_32] = apply_r_mips_32,
540 [R_MIPS_26] = apply_r_mips_26,
541 [R_MIPS_HI16] = apply_r_mips_hi16,
542 [R_MIPS_LO16] = apply_r_mips_lo16,
543 [R_MIPS_GPREL16] = apply_r_mips_gprel16,
544 [R_MIPS_PC16] = apply_r_mips_pc16
545};
546
547static char *rstrs[] = {
548 [R_MIPS_NONE] = "MIPS_NONE",
549 [R_MIPS_32] = "MIPS_32",
550 [R_MIPS_26] = "MIPS_26",
551 [R_MIPS_HI16] = "MIPS_HI16",
552 [R_MIPS_LO16] = "MIPS_LO16",
553 [R_MIPS_GPREL16] = "MIPS_GPREL16",
554 [R_MIPS_PC16] = "MIPS_PC16"
555};
556
557static int apply_relocations(Elf32_Shdr *sechdrs,
558 const char *strtab,
559 unsigned int symindex,
560 unsigned int relsec,
561 struct module *me)
562{
563 Elf32_Rel *rel = (void *) sechdrs[relsec].sh_addr;
564 Elf32_Sym *sym;
565 uint32_t *location;
566 unsigned int i;
567 Elf32_Addr v;
568 int res;
569
570 for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {
571 Elf32_Word r_info = rel[i].r_info;
572
573
574 location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr
575 + rel[i].r_offset;
576
577 sym = (Elf32_Sym *)sechdrs[symindex].sh_addr
578 + ELF32_R_SYM(r_info);
579
580 if (!sym->st_value) {
581 printk(KERN_DEBUG "%s: undefined weak symbol %s\n",
582 me->name, strtab + sym->st_name);
583
584 }
585
586 v = sym->st_value;
587
588 res = reloc_handlers[ELF32_R_TYPE(r_info)](me, location, v);
589 if( res ) {
590 char *r = rstrs[ELF32_R_TYPE(r_info)];
591 printk(KERN_WARNING "VPE loader: .text+0x%x "
592 "relocation type %s for symbol \"%s\" failed\n",
593 rel[i].r_offset, r ? r : "UNKNOWN",
594 strtab + sym->st_name);
595 return res;
596 }
597 }
598
599 return 0;
600}
601
602static inline void save_gp_address(unsigned int secbase, unsigned int rel)
603{
604 gp_addr = secbase + rel;
605 gp_offs = gp_addr - (secbase & 0xffff0000);
606}
607
608
609
610
611
612static void simplify_symbols(Elf_Shdr * sechdrs,
613 unsigned int symindex,
614 const char *strtab,
615 const char *secstrings,
616 unsigned int nsecs, struct module *mod)
617{
618 Elf_Sym *sym = (void *)sechdrs[symindex].sh_addr;
619 unsigned long secbase, bssbase = 0;
620 unsigned int i, n = sechdrs[symindex].sh_size / sizeof(Elf_Sym);
621 int size;
622
623
624 for (i = 0; i < nsecs; i++) {
625 if (strncmp(secstrings + sechdrs[i].sh_name, ".bss", 4) == 0) {
626 bssbase = sechdrs[i].sh_addr;
627 break;
628 }
629 }
630
631 for (i = 1; i < n; i++) {
632 switch (sym[i].st_shndx) {
633 case SHN_COMMON:
634
635
636
637
638 size = sym[i].st_value;
639 sym[i].st_value = bssbase;
640
641 bssbase += size;
642 break;
643
644 case SHN_ABS:
645
646 break;
647
648 case SHN_UNDEF:
649
650 break;
651
652 case SHN_MIPS_SCOMMON:
653 printk(KERN_DEBUG "simplify_symbols: ignoring SHN_MIPS_SCOMMON "
654 "symbol <%s> st_shndx %d\n", strtab + sym[i].st_name,
655 sym[i].st_shndx);
656
657 break;
658
659 default:
660 secbase = sechdrs[sym[i].st_shndx].sh_addr;
661
662 if (strncmp(strtab + sym[i].st_name, "_gp", 3) == 0) {
663 save_gp_address(secbase, sym[i].st_value);
664 }
665
666 sym[i].st_value += secbase;
667 break;
668 }
669 }
670}
671
672#ifdef DEBUG_ELFLOADER
673static void dump_elfsymbols(Elf_Shdr * sechdrs, unsigned int symindex,
674 const char *strtab, struct module *mod)
675{
676 Elf_Sym *sym = (void *)sechdrs[symindex].sh_addr;
677 unsigned int i, n = sechdrs[symindex].sh_size / sizeof(Elf_Sym);
678
679 printk(KERN_DEBUG "dump_elfsymbols: n %d\n", n);
680 for (i = 1; i < n; i++) {
681 printk(KERN_DEBUG " i %d name <%s> 0x%x\n", i,
682 strtab + sym[i].st_name, sym[i].st_value);
683 }
684}
685#endif
686
687
688static int vpe_run(struct vpe * v)
689{
690 unsigned long flags, val, dmt_flag;
691 struct vpe_notifications *n;
692 unsigned int vpeflags;
693 struct tc *t;
694
695
696 local_irq_save(flags);
697 val = read_c0_vpeconf0();
698 if (!(val & VPECONF0_MVP)) {
699 printk(KERN_WARNING
700 "VPE loader: only Master VPE's are allowed to configure MT\n");
701 local_irq_restore(flags);
702
703 return -1;
704 }
705
706 dmt_flag = dmt();
707 vpeflags = dvpe();
708
709 if (!list_empty(&v->tc)) {
710 if ((t = list_entry(v->tc.next, struct tc, tc)) == NULL) {
711 evpe(vpeflags);
712 emt(dmt_flag);
713 local_irq_restore(flags);
714
715 printk(KERN_WARNING
716 "VPE loader: TC %d is already in use.\n",
717 t->index);
718 return -ENOEXEC;
719 }
720 } else {
721 evpe(vpeflags);
722 emt(dmt_flag);
723 local_irq_restore(flags);
724
725 printk(KERN_WARNING
726 "VPE loader: No TC's associated with VPE %d\n",
727 v->minor);
728
729 return -ENOEXEC;
730 }
731
732
733 set_c0_mvpcontrol(MVPCONTROL_VPC);
734
735 settc(t->index);
736
737
738 if ((read_tc_c0_tcstatus() & TCSTATUS_A) || !(read_tc_c0_tchalt() & TCHALT_H)) {
739 evpe(vpeflags);
740 emt(dmt_flag);
741 local_irq_restore(flags);
742
743 printk(KERN_WARNING "VPE loader: TC %d is already active!\n",
744 t->index);
745
746 return -ENOEXEC;
747 }
748
749
750 write_tc_c0_tcrestart((unsigned long)v->__start);
751 write_tc_c0_tccontext((unsigned long)0);
752
753
754
755
756
757 val = read_tc_c0_tcstatus();
758 val = (val & ~(TCSTATUS_DA | TCSTATUS_IXMT)) | TCSTATUS_A;
759 write_tc_c0_tcstatus(val);
760
761 write_tc_c0_tchalt(read_tc_c0_tchalt() & ~TCHALT_H);
762
763
764
765
766
767
768 mttgpr(6, v->ntcs);
769 mttgpr(7, physical_memsize);
770
771
772
773
774
775
776 write_tc_c0_tcbind((read_tc_c0_tcbind() & ~TCBIND_CURVPE) | 1);
777
778 write_vpe_c0_vpeconf0(read_vpe_c0_vpeconf0() & ~(VPECONF0_VPA));
779
780 back_to_back_c0_hazard();
781
782
783 write_vpe_c0_vpeconf0( (read_vpe_c0_vpeconf0() & ~(VPECONF0_XTC))
784 | (t->index << VPECONF0_XTC_SHIFT));
785
786 back_to_back_c0_hazard();
787
788
789 write_vpe_c0_vpeconf0(read_vpe_c0_vpeconf0() | VPECONF0_VPA);
790
791
792 write_vpe_c0_status(0);
793 write_vpe_c0_cause(0);
794
795
796 clear_c0_mvpcontrol(MVPCONTROL_VPC);
797
798
799
800
801
802
803#ifdef CONFIG_SMP
804 evpe(vpeflags);
805#else
806 evpe(EVPE_ENABLE);
807#endif
808 emt(dmt_flag);
809 local_irq_restore(flags);
810
811 list_for_each_entry(n, &v->notify, list)
812 n->start(minor);
813
814 return 0;
815}
816
817static int find_vpe_symbols(struct vpe * v, Elf_Shdr * sechdrs,
818 unsigned int symindex, const char *strtab,
819 struct module *mod)
820{
821 Elf_Sym *sym = (void *)sechdrs[symindex].sh_addr;
822 unsigned int i, n = sechdrs[symindex].sh_size / sizeof(Elf_Sym);
823
824 for (i = 1; i < n; i++) {
825 if (strcmp(strtab + sym[i].st_name, "__start") == 0) {
826 v->__start = sym[i].st_value;
827 }
828
829 if (strcmp(strtab + sym[i].st_name, "vpe_shared") == 0) {
830 v->shared_ptr = (void *)sym[i].st_value;
831 }
832 }
833
834 if ( (v->__start == 0) || (v->shared_ptr == NULL))
835 return -1;
836
837 return 0;
838}
839
840
841
842
843
844
845static int vpe_elfload(struct vpe * v)
846{
847 Elf_Ehdr *hdr;
848 Elf_Shdr *sechdrs;
849 long err = 0;
850 char *secstrings, *strtab = NULL;
851 unsigned int len, i, symindex = 0, strindex = 0, relocate = 0;
852 struct module mod;
853
854 memset(&mod, 0, sizeof(struct module));
855 strcpy(mod.name, "VPE loader");
856
857 hdr = (Elf_Ehdr *) v->pbuffer;
858 len = v->plen;
859
860
861
862 if (memcmp(hdr->e_ident, ELFMAG, SELFMAG) != 0
863 || (hdr->e_type != ET_REL && hdr->e_type != ET_EXEC)
864 || !elf_check_arch(hdr)
865 || hdr->e_shentsize != sizeof(*sechdrs)) {
866 printk(KERN_WARNING
867 "VPE loader: program wrong arch or weird elf version\n");
868
869 return -ENOEXEC;
870 }
871
872 if (hdr->e_type == ET_REL)
873 relocate = 1;
874
875 if (len < hdr->e_shoff + hdr->e_shnum * sizeof(Elf_Shdr)) {
876 printk(KERN_ERR "VPE loader: program length %u truncated\n",
877 len);
878
879 return -ENOEXEC;
880 }
881
882
883 sechdrs = (void *)hdr + hdr->e_shoff;
884 secstrings = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;
885 sechdrs[0].sh_addr = 0;
886
887
888 symindex = strindex = 0;
889
890 if (relocate) {
891 for (i = 1; i < hdr->e_shnum; i++) {
892 if (sechdrs[i].sh_type != SHT_NOBITS
893 && len < sechdrs[i].sh_offset + sechdrs[i].sh_size) {
894 printk(KERN_ERR "VPE program length %u truncated\n",
895 len);
896 return -ENOEXEC;
897 }
898
899
900
901 sechdrs[i].sh_addr = (size_t) hdr + sechdrs[i].sh_offset;
902
903
904 if (sechdrs[i].sh_type == SHT_SYMTAB) {
905 symindex = i;
906 strindex = sechdrs[i].sh_link;
907 strtab = (char *)hdr + sechdrs[strindex].sh_offset;
908 }
909 }
910 layout_sections(&mod, hdr, sechdrs, secstrings);
911 }
912
913 v->load_addr = alloc_progmem(mod.core_size);
914 if (!v->load_addr)
915 return -ENOMEM;
916
917 pr_info("VPE loader: loading to %p\n", v->load_addr);
918
919 if (relocate) {
920 for (i = 0; i < hdr->e_shnum; i++) {
921 void *dest;
922
923 if (!(sechdrs[i].sh_flags & SHF_ALLOC))
924 continue;
925
926 dest = v->load_addr + sechdrs[i].sh_entsize;
927
928 if (sechdrs[i].sh_type != SHT_NOBITS)
929 memcpy(dest, (void *)sechdrs[i].sh_addr,
930 sechdrs[i].sh_size);
931
932 sechdrs[i].sh_addr = (unsigned long)dest;
933
934 printk(KERN_DEBUG " section sh_name %s sh_addr 0x%x\n",
935 secstrings + sechdrs[i].sh_name, sechdrs[i].sh_addr);
936 }
937
938
939 simplify_symbols(sechdrs, symindex, strtab, secstrings,
940 hdr->e_shnum, &mod);
941
942
943 for (i = 1; i < hdr->e_shnum; i++) {
944 const char *strtab = (char *)sechdrs[strindex].sh_addr;
945 unsigned int info = sechdrs[i].sh_info;
946
947
948 if (info >= hdr->e_shnum)
949 continue;
950
951
952 if (!(sechdrs[info].sh_flags & SHF_ALLOC))
953 continue;
954
955 if (sechdrs[i].sh_type == SHT_REL)
956 err = apply_relocations(sechdrs, strtab, symindex, i,
957 &mod);
958 else if (sechdrs[i].sh_type == SHT_RELA)
959 err = apply_relocate_add(sechdrs, strtab, symindex, i,
960 &mod);
961 if (err < 0)
962 return err;
963
964 }
965 } else {
966 struct elf_phdr *phdr = (struct elf_phdr *) ((char *)hdr + hdr->e_phoff);
967
968 for (i = 0; i < hdr->e_phnum; i++) {
969 if (phdr->p_type == PT_LOAD) {
970 memcpy((void *)phdr->p_paddr,
971 (char *)hdr + phdr->p_offset,
972 phdr->p_filesz);
973 memset((void *)phdr->p_paddr + phdr->p_filesz,
974 0, phdr->p_memsz - phdr->p_filesz);
975 }
976 phdr++;
977 }
978
979 for (i = 0; i < hdr->e_shnum; i++) {
980
981 if (sechdrs[i].sh_type == SHT_SYMTAB) {
982 symindex = i;
983 strindex = sechdrs[i].sh_link;
984 strtab = (char *)hdr + sechdrs[strindex].sh_offset;
985
986
987
988 sechdrs[i].sh_addr = (size_t) hdr + sechdrs[i].sh_offset;
989 }
990 }
991 }
992
993
994 flush_icache_range((unsigned long)v->load_addr,
995 (unsigned long)v->load_addr + v->len);
996
997 if ((find_vpe_symbols(v, sechdrs, symindex, strtab, &mod)) < 0) {
998 if (v->__start == 0) {
999 printk(KERN_WARNING "VPE loader: program does not contain "
1000 "a __start symbol\n");
1001 return -ENOEXEC;
1002 }
1003
1004 if (v->shared_ptr == NULL)
1005 printk(KERN_WARNING "VPE loader: "
1006 "program does not contain vpe_shared symbol.\n"
1007 " Unable to use AMVP (AP/SP) facilities.\n");
1008 }
1009
1010 printk(" elf loaded\n");
1011 return 0;
1012}
1013
1014static void cleanup_tc(struct tc *tc)
1015{
1016 unsigned long flags;
1017 unsigned int mtflags, vpflags;
1018 int tmp;
1019
1020 local_irq_save(flags);
1021 mtflags = dmt();
1022 vpflags = dvpe();
1023
1024 set_c0_mvpcontrol(MVPCONTROL_VPC);
1025
1026 settc(tc->index);
1027 tmp = read_tc_c0_tcstatus();
1028
1029
1030 tmp &= ~(TCSTATUS_A | TCSTATUS_DA);
1031 tmp |= TCSTATUS_IXMT;
1032 write_tc_c0_tcstatus(tmp);
1033
1034 write_tc_c0_tchalt(TCHALT_H);
1035 mips_ihb();
1036
1037
1038
1039
1040 clear_c0_mvpcontrol(MVPCONTROL_VPC);
1041 evpe(vpflags);
1042 emt(mtflags);
1043 local_irq_restore(flags);
1044}
1045
1046static int getcwd(char *buff, int size)
1047{
1048 mm_segment_t old_fs;
1049 int ret;
1050
1051 old_fs = get_fs();
1052 set_fs(KERNEL_DS);
1053
1054 ret = sys_getcwd(buff, size);
1055
1056 set_fs(old_fs);
1057
1058 return ret;
1059}
1060
1061
1062static int vpe_open(struct inode *inode, struct file *filp)
1063{
1064 enum vpe_state state;
1065 struct vpe_notifications *not;
1066 struct vpe *v;
1067 int ret;
1068
1069 if (minor != iminor(inode)) {
1070
1071 pr_warning("VPE loader: only vpe1 is supported\n");
1072
1073 return -ENODEV;
1074 }
1075
1076 if ((v = get_vpe(tclimit)) == NULL) {
1077 pr_warning("VPE loader: unable to get vpe\n");
1078
1079 return -ENODEV;
1080 }
1081
1082 state = xchg(&v->state, VPE_STATE_INUSE);
1083 if (state != VPE_STATE_UNUSED) {
1084 printk(KERN_DEBUG "VPE loader: tc in use dumping regs\n");
1085
1086 list_for_each_entry(not, &v->notify, list) {
1087 not->stop(tclimit);
1088 }
1089
1090 release_progmem(v->load_addr);
1091 cleanup_tc(get_tc(tclimit));
1092 }
1093
1094
1095 v->pbuffer = vmalloc(P_SIZE);
1096 v->plen = P_SIZE;
1097 v->load_addr = NULL;
1098 v->len = 0;
1099
1100 v->uid = filp->f_cred->fsuid;
1101 v->gid = filp->f_cred->fsgid;
1102
1103#ifdef CONFIG_MIPS_APSP_KSPD
1104
1105 if (!kspd_events_reqd) {
1106 kspd_notify(&kspd_events);
1107 kspd_events_reqd++;
1108 }
1109#endif
1110
1111 v->cwd[0] = 0;
1112 ret = getcwd(v->cwd, VPE_PATH_MAX);
1113 if (ret < 0)
1114 printk(KERN_WARNING "VPE loader: open, getcwd returned %d\n", ret);
1115
1116 v->shared_ptr = NULL;
1117 v->__start = 0;
1118
1119 return 0;
1120}
1121
1122static int vpe_release(struct inode *inode, struct file *filp)
1123{
1124 struct vpe *v;
1125 Elf_Ehdr *hdr;
1126 int ret = 0;
1127
1128 v = get_vpe(tclimit);
1129 if (v == NULL)
1130 return -ENODEV;
1131
1132 hdr = (Elf_Ehdr *) v->pbuffer;
1133 if (memcmp(hdr->e_ident, ELFMAG, SELFMAG) == 0) {
1134 if (vpe_elfload(v) >= 0) {
1135 vpe_run(v);
1136 } else {
1137 printk(KERN_WARNING "VPE loader: ELF load failed.\n");
1138 ret = -ENOEXEC;
1139 }
1140 } else {
1141 printk(KERN_WARNING "VPE loader: only elf files are supported\n");
1142 ret = -ENOEXEC;
1143 }
1144
1145
1146
1147
1148
1149
1150 if (ret < 0)
1151 v->shared_ptr = NULL;
1152
1153
1154 if (v->pbuffer)
1155 vfree(v->pbuffer);
1156 v->plen = 0;
1157 return ret;
1158}
1159
1160static ssize_t vpe_write(struct file *file, const char __user * buffer,
1161 size_t count, loff_t * ppos)
1162{
1163 size_t ret = count;
1164 struct vpe *v;
1165
1166 if (iminor(file->f_path.dentry->d_inode) != minor)
1167 return -ENODEV;
1168
1169 v = get_vpe(tclimit);
1170 if (v == NULL)
1171 return -ENODEV;
1172
1173 if (v->pbuffer == NULL) {
1174 printk(KERN_ERR "VPE loader: no buffer for program\n");
1175 return -ENOMEM;
1176 }
1177
1178 if ((count + v->len) > v->plen) {
1179 printk(KERN_WARNING
1180 "VPE loader: elf size too big. Perhaps strip uneeded symbols\n");
1181 return -ENOMEM;
1182 }
1183
1184 count -= copy_from_user(v->pbuffer + v->len, buffer, count);
1185 if (!count)
1186 return -EFAULT;
1187
1188 v->len += count;
1189 return ret;
1190}
1191
1192static const struct file_operations vpe_fops = {
1193 .owner = THIS_MODULE,
1194 .open = vpe_open,
1195 .release = vpe_release,
1196 .write = vpe_write
1197};
1198
1199
1200
1201vpe_handle vpe_alloc(void)
1202{
1203 int i;
1204 struct vpe *v;
1205
1206
1207 for (i = 1; i < MAX_VPES; i++) {
1208 if ((v = get_vpe(i)) != NULL) {
1209 v->state = VPE_STATE_INUSE;
1210 return v;
1211 }
1212 }
1213 return NULL;
1214}
1215
1216EXPORT_SYMBOL(vpe_alloc);
1217
1218
1219int vpe_start(vpe_handle vpe, unsigned long start)
1220{
1221 struct vpe *v = vpe;
1222
1223 v->__start = start;
1224 return vpe_run(v);
1225}
1226
1227EXPORT_SYMBOL(vpe_start);
1228
1229
1230int vpe_stop(vpe_handle vpe)
1231{
1232 struct vpe *v = vpe;
1233 struct tc *t;
1234 unsigned int evpe_flags;
1235
1236 evpe_flags = dvpe();
1237
1238 if ((t = list_entry(v->tc.next, struct tc, tc)) != NULL) {
1239
1240 settc(t->index);
1241 write_vpe_c0_vpeconf0(read_vpe_c0_vpeconf0() & ~VPECONF0_VPA);
1242 }
1243
1244 evpe(evpe_flags);
1245
1246 return 0;
1247}
1248
1249EXPORT_SYMBOL(vpe_stop);
1250
1251
1252int vpe_free(vpe_handle vpe)
1253{
1254 struct vpe *v = vpe;
1255 struct tc *t;
1256 unsigned int evpe_flags;
1257
1258 if ((t = list_entry(v->tc.next, struct tc, tc)) == NULL) {
1259 return -ENOEXEC;
1260 }
1261
1262 evpe_flags = dvpe();
1263
1264
1265 set_c0_mvpcontrol(MVPCONTROL_VPC);
1266
1267 settc(t->index);
1268 write_vpe_c0_vpeconf0(read_vpe_c0_vpeconf0() & ~VPECONF0_VPA);
1269
1270
1271 write_tc_c0_tchalt(TCHALT_H);
1272 mips_ihb();
1273
1274
1275 write_tc_c0_tcstatus(read_tc_c0_tcstatus() & ~TCSTATUS_A);
1276
1277 v->state = VPE_STATE_UNUSED;
1278
1279 clear_c0_mvpcontrol(MVPCONTROL_VPC);
1280 evpe(evpe_flags);
1281
1282 return 0;
1283}
1284
1285EXPORT_SYMBOL(vpe_free);
1286
1287void *vpe_get_shared(int index)
1288{
1289 struct vpe *v;
1290
1291 if ((v = get_vpe(index)) == NULL)
1292 return NULL;
1293
1294 return v->shared_ptr;
1295}
1296
1297EXPORT_SYMBOL(vpe_get_shared);
1298
1299int vpe_getuid(int index)
1300{
1301 struct vpe *v;
1302
1303 if ((v = get_vpe(index)) == NULL)
1304 return -1;
1305
1306 return v->uid;
1307}
1308
1309EXPORT_SYMBOL(vpe_getuid);
1310
1311int vpe_getgid(int index)
1312{
1313 struct vpe *v;
1314
1315 if ((v = get_vpe(index)) == NULL)
1316 return -1;
1317
1318 return v->gid;
1319}
1320
1321EXPORT_SYMBOL(vpe_getgid);
1322
1323int vpe_notify(int index, struct vpe_notifications *notify)
1324{
1325 struct vpe *v;
1326
1327 if ((v = get_vpe(index)) == NULL)
1328 return -1;
1329
1330 list_add(¬ify->list, &v->notify);
1331 return 0;
1332}
1333
1334EXPORT_SYMBOL(vpe_notify);
1335
1336char *vpe_getcwd(int index)
1337{
1338 struct vpe *v;
1339
1340 if ((v = get_vpe(index)) == NULL)
1341 return NULL;
1342
1343 return v->cwd;
1344}
1345
1346EXPORT_SYMBOL(vpe_getcwd);
1347
1348#ifdef CONFIG_MIPS_APSP_KSPD
1349static void kspd_sp_exit( int sp_id)
1350{
1351 cleanup_tc(get_tc(sp_id));
1352}
1353#endif
1354
1355static ssize_t store_kill(struct device *dev, struct device_attribute *attr,
1356 const char *buf, size_t len)
1357{
1358 struct vpe *vpe = get_vpe(tclimit);
1359 struct vpe_notifications *not;
1360
1361 list_for_each_entry(not, &vpe->notify, list) {
1362 not->stop(tclimit);
1363 }
1364
1365 release_progmem(vpe->load_addr);
1366 cleanup_tc(get_tc(tclimit));
1367 vpe_stop(vpe);
1368 vpe_free(vpe);
1369
1370 return len;
1371}
1372
1373static ssize_t show_ntcs(struct device *cd, struct device_attribute *attr,
1374 char *buf)
1375{
1376 struct vpe *vpe = get_vpe(tclimit);
1377
1378 return sprintf(buf, "%d\n", vpe->ntcs);
1379}
1380
1381static ssize_t store_ntcs(struct device *dev, struct device_attribute *attr,
1382 const char *buf, size_t len)
1383{
1384 struct vpe *vpe = get_vpe(tclimit);
1385 unsigned long new;
1386 char *endp;
1387
1388 new = simple_strtoul(buf, &endp, 0);
1389 if (endp == buf)
1390 goto out_einval;
1391
1392 if (new == 0 || new > (hw_tcs - tclimit))
1393 goto out_einval;
1394
1395 vpe->ntcs = new;
1396
1397 return len;
1398
1399out_einval:
1400 return -EINVAL;
1401}
1402
1403static struct device_attribute vpe_class_attributes[] = {
1404 __ATTR(kill, S_IWUSR, NULL, store_kill),
1405 __ATTR(ntcs, S_IRUGO | S_IWUSR, show_ntcs, store_ntcs),
1406 {}
1407};
1408
1409static void vpe_device_release(struct device *cd)
1410{
1411 kfree(cd);
1412}
1413
1414struct class vpe_class = {
1415 .name = "vpe",
1416 .owner = THIS_MODULE,
1417 .dev_release = vpe_device_release,
1418 .dev_attrs = vpe_class_attributes,
1419};
1420
1421struct device vpe_device;
1422
1423static int __init vpe_module_init(void)
1424{
1425 unsigned int mtflags, vpflags;
1426 unsigned long flags, val;
1427 struct vpe *v = NULL;
1428 struct tc *t;
1429 int tc, err;
1430
1431 if (!cpu_has_mipsmt) {
1432 printk("VPE loader: not a MIPS MT capable processor\n");
1433 return -ENODEV;
1434 }
1435
1436 if (vpelimit == 0) {
1437 printk(KERN_WARNING "No VPEs reserved for AP/SP, not "
1438 "initializing VPE loader.\nPass maxvpes=<n> argument as "
1439 "kernel argument\n");
1440
1441 return -ENODEV;
1442 }
1443
1444 if (tclimit == 0) {
1445 printk(KERN_WARNING "No TCs reserved for AP/SP, not "
1446 "initializing VPE loader.\nPass maxtcs=<n> argument as "
1447 "kernel argument\n");
1448
1449 return -ENODEV;
1450 }
1451
1452 major = register_chrdev(0, module_name, &vpe_fops);
1453 if (major < 0) {
1454 printk("VPE loader: unable to register character device\n");
1455 return major;
1456 }
1457
1458 err = class_register(&vpe_class);
1459 if (err) {
1460 printk(KERN_ERR "vpe_class registration failed\n");
1461 goto out_chrdev;
1462 }
1463
1464 device_initialize(&vpe_device);
1465 vpe_device.class = &vpe_class,
1466 vpe_device.parent = NULL,
1467 dev_set_name(&vpe_device, "vpe1");
1468 vpe_device.devt = MKDEV(major, minor);
1469 err = device_add(&vpe_device);
1470 if (err) {
1471 printk(KERN_ERR "Adding vpe_device failed\n");
1472 goto out_class;
1473 }
1474
1475 local_irq_save(flags);
1476 mtflags = dmt();
1477 vpflags = dvpe();
1478
1479
1480 set_c0_mvpcontrol(MVPCONTROL_VPC);
1481
1482
1483
1484 val = read_c0_mvpconf0();
1485 hw_tcs = (val & MVPCONF0_PTC) + 1;
1486 hw_vpes = ((val & MVPCONF0_PVPE) >> MVPCONF0_PVPE_SHIFT) + 1;
1487
1488 for (tc = tclimit; tc < hw_tcs; tc++) {
1489
1490
1491
1492
1493 clear_c0_mvpcontrol(MVPCONTROL_VPC);
1494 evpe(vpflags);
1495 emt(mtflags);
1496 local_irq_restore(flags);
1497 t = alloc_tc(tc);
1498 if (!t) {
1499 err = -ENOMEM;
1500 goto out;
1501 }
1502
1503 local_irq_save(flags);
1504 mtflags = dmt();
1505 vpflags = dvpe();
1506 set_c0_mvpcontrol(MVPCONTROL_VPC);
1507
1508
1509 if (tc < hw_tcs) {
1510 settc(tc);
1511
1512 if ((v = alloc_vpe(tc)) == NULL) {
1513 printk(KERN_WARNING "VPE: unable to allocate VPE\n");
1514
1515 goto out_reenable;
1516 }
1517
1518 v->ntcs = hw_tcs - tclimit;
1519
1520
1521 list_add(&t->tc, &v->tc);
1522
1523
1524 if (tc >= tclimit) {
1525 unsigned long tmp = read_vpe_c0_vpeconf0();
1526
1527 tmp &= ~VPECONF0_VPA;
1528
1529
1530 tmp |= VPECONF0_MVP;
1531 write_vpe_c0_vpeconf0(tmp);
1532 }
1533
1534
1535 write_vpe_c0_vpecontrol(read_vpe_c0_vpecontrol() & ~VPECONTROL_TE);
1536
1537 if (tc >= vpelimit) {
1538
1539
1540
1541
1542 write_vpe_c0_config(read_c0_config());
1543 }
1544 }
1545
1546
1547 t->pvpe = v;
1548
1549 if (tc >= tclimit) {
1550 unsigned long tmp;
1551
1552 settc(tc);
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564 if (((tmp = read_tc_c0_tcbind()) & TCBIND_CURVPE)) {
1565
1566 write_tc_c0_tcbind(tmp & ~TCBIND_CURVPE);
1567
1568 t->pvpe = get_vpe(0);
1569 }
1570
1571
1572 write_tc_c0_tchalt(TCHALT_H);
1573 mips_ihb();
1574
1575 tmp = read_tc_c0_tcstatus();
1576
1577
1578 tmp &= ~(TCSTATUS_A | TCSTATUS_DA);
1579 tmp |= TCSTATUS_IXMT;
1580 write_tc_c0_tcstatus(tmp);
1581 }
1582 }
1583
1584out_reenable:
1585
1586 clear_c0_mvpcontrol(MVPCONTROL_VPC);
1587
1588 evpe(vpflags);
1589 emt(mtflags);
1590 local_irq_restore(flags);
1591
1592#ifdef CONFIG_MIPS_APSP_KSPD
1593 kspd_events.kspd_sp_exit = kspd_sp_exit;
1594#endif
1595 return 0;
1596
1597out_class:
1598 class_unregister(&vpe_class);
1599out_chrdev:
1600 unregister_chrdev(major, module_name);
1601
1602out:
1603 return err;
1604}
1605
1606static void __exit vpe_module_exit(void)
1607{
1608 struct vpe *v, *n;
1609
1610 device_del(&vpe_device);
1611 unregister_chrdev(major, module_name);
1612
1613
1614 list_for_each_entry_safe(v, n, &vpecontrol.vpe_list, list) {
1615 if (v->state != VPE_STATE_UNUSED)
1616 release_vpe(v);
1617 }
1618}
1619
1620module_init(vpe_module_init);
1621module_exit(vpe_module_exit);
1622MODULE_DESCRIPTION("MIPS VPE Loader");
1623MODULE_AUTHOR("Elizabeth Oldham, MIPS Technologies, Inc.");
1624MODULE_LICENSE("GPL");
1625