1 /* 2 * Copyright (C) 2004, 2005 MIPS Technologies, Inc. All rights reserved. 3 * 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. 7 * 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 11 * for more details. 12 * 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. 16 */ 17 18 /* 19 * VPE support module 20 * 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. 26 * 27 * To load and run, simply cat a SP 'program file' to /dev/vpe1. 28 * i.e cat spapp >/dev/vpe1. 29 */ 30 31 #include <linux/kernel.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/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> 50 #include <asm/cpu.h> 51 #include <asm/processor.h> 52 #include <asm/system.h> 53 #include <asm/vpe.h> 54 #include <asm/kspd.h> 55 56 typedef void *vpe_handle; 57 58 #ifndef ARCH_SHF_SMALL 59 #define ARCH_SHF_SMALL 0 60 #endif 61 62 /* If this is set, the section belongs in the init part of the module */ 63 #define INIT_OFFSET_MASK (1UL << (BITS_PER_LONG-1)) 64 65 static char module_name[] = "vpe"; 66 static int major; 67 68 #ifdef CONFIG_MIPS_APSP_KSPD 69 static struct kspd_notifications kspd_events; 70 static int kspd_events_reqd = 0; 71 #endif 72 73 /* grab the likely amount of memory we will need. */ 74 #ifdef CONFIG_MIPS_VPE_LOADER_TOM 75 #define P_SIZE (2 * 1024 * 1024) 76 #else 77 /* add an overhead to the max kmalloc size for non-striped symbols/etc */ 78 #define P_SIZE (256 * 1024) 79 #endif 80 81 extern unsigned long physical_memsize; 82 83 #define MAX_VPES 16 84 #define VPE_PATH_MAX 256 85 86 enum vpe_state { 87 VPE_STATE_UNUSED = 0, 88 VPE_STATE_INUSE, 89 VPE_STATE_RUNNING 90 }; 91 92 enum tc_state { 93 TC_STATE_UNUSED = 0, 94 TC_STATE_INUSE, 95 TC_STATE_RUNNING, 96 TC_STATE_DYNAMIC 97 }; 98 99 struct vpe { 100 enum vpe_state state; 101 102 /* (device) minor associated with this vpe */ 103 int minor; 104 105 /* elfloader stuff */ 106 void *load_addr; 107 unsigned long len; 108 char *pbuffer; 109 unsigned long plen; 110 unsigned int uid, gid; 111 char cwd[VPE_PATH_MAX]; 112 113 unsigned long __start; 114 115 /* tc's associated with this vpe */ 116 struct list_head tc; 117 118 /* The list of vpe's */ 119 struct list_head list; 120 121 /* shared symbol address */ 122 void *shared_ptr; 123 124 /* the list of who wants to know when something major happens */ 125 struct list_head notify; 126 }; 127 128 struct tc { 129 enum tc_state state; 130 int index; 131 132 /* parent VPE */ 133 struct vpe *pvpe; 134 135 /* The list of TC's with this VPE */ 136 struct list_head tc; 137 138 /* The global list of tc's */ 139 struct list_head list; 140 }; 141 142 struct { 143 /* Virtual processing elements */ 144 struct list_head vpe_list; 145 146 /* Thread contexts */ 147 struct list_head tc_list; 148 } vpecontrol = { 149 .vpe_list = LIST_HEAD_INIT(vpecontrol.vpe_list), 150 .tc_list = LIST_HEAD_INIT(vpecontrol.tc_list) 151 }; 152 153 static void release_progmem(void *ptr); 154 /* static __attribute_used__ void dump_vpe(struct vpe * v); */ 155 extern void save_gp_address(unsigned int secbase, unsigned int rel); 156 157 /* get the vpe associated with this minor */ 158 struct vpe *get_vpe(int minor) 159 { 160 struct vpe *v; 161 162 if (!cpu_has_mipsmt) 163 return NULL; 164 165 list_for_each_entry(v, &vpecontrol.vpe_list, list) { 166 if (v->minor == minor) 167 return v; 168 } 169 170 return NULL; 171 } 172 173 /* get the vpe associated with this minor */ 174 struct tc *get_tc(int index) 175 { 176 struct tc *t; 177 178 list_for_each_entry(t, &vpecontrol.tc_list, list) { 179 if (t->index == index) 180 return t; 181 } 182 183 return NULL; 184 } 185 186 struct tc *get_tc_unused(void) 187 { 188 struct tc *t; 189 190 list_for_each_entry(t, &vpecontrol.tc_list, list) { 191 if (t->state == TC_STATE_UNUSED) 192 return t; 193 } 194 195 return NULL; 196 } 197 198 /* allocate a vpe and associate it with this minor (or index) */ 199 struct vpe *alloc_vpe(int minor) 200 { 201 struct vpe *v; 202 203 if ((v = kzalloc(sizeof(struct vpe), GFP_KERNEL)) == NULL) { 204 return NULL; 205 } 206 207 INIT_LIST_HEAD(&v->tc); 208 list_add_tail(&v->list, &vpecontrol.vpe_list); 209 210 INIT_LIST_HEAD(&v->notify); 211 v->minor = minor; 212 return v; 213 } 214 215 /* allocate a tc. At startup only tc0 is running, all other can be halted. */ 216 struct tc *alloc_tc(int index) 217 { 218 struct tc *t; 219 220 if ((t = kzalloc(sizeof(struct tc), GFP_KERNEL)) == NULL) { 221 return NULL; 222 } 223 224 INIT_LIST_HEAD(&t->tc); 225 list_add_tail(&t->list, &vpecontrol.tc_list); 226 227 t->index = index; 228 229 return t; 230 } 231 232 /* clean up and free everything */ 233 void release_vpe(struct vpe *v) 234 { 235 list_del(&v->list); 236 if (v->load_addr) 237 release_progmem(v); 238 kfree(v); 239 } 240 241 void dump_mtregs(void) 242 { 243 unsigned long val; 244 245 val = read_c0_config3(); 246 printk("config3 0x%lx MT %ld\n", val, 247 (val & CONFIG3_MT) >> CONFIG3_MT_SHIFT); 248 249 val = read_c0_mvpcontrol(); 250 printk("MVPControl 0x%lx, STLB %ld VPC %ld EVP %ld\n", val, 251 (val & MVPCONTROL_STLB) >> MVPCONTROL_STLB_SHIFT, 252 (val & MVPCONTROL_VPC) >> MVPCONTROL_VPC_SHIFT, 253 (val & MVPCONTROL_EVP)); 254 255 val = read_c0_mvpconf0(); 256 printk("mvpconf0 0x%lx, PVPE %ld PTC %ld M %ld\n", val, 257 (val & MVPCONF0_PVPE) >> MVPCONF0_PVPE_SHIFT, 258 val & MVPCONF0_PTC, (val & MVPCONF0_M) >> MVPCONF0_M_SHIFT); 259 } 260 261 /* Find some VPE program space */ 262 static void *alloc_progmem(unsigned long len) 263 { 264 #ifdef CONFIG_MIPS_VPE_LOADER_TOM 265 /* this means you must tell linux to use less memory than you physically have */ 266 return pfn_to_kaddr(max_pfn); 267 #else 268 // simple grab some mem for now 269 return kmalloc(len, GFP_KERNEL); 270 #endif 271 } 272 273 static void release_progmem(void *ptr) 274 { 275 #ifndef CONFIG_MIPS_VPE_LOADER_TOM 276 kfree(ptr); 277 #endif 278 } 279 280 /* Update size with this section: return offset. */ 281 static long get_offset(unsigned long *size, Elf_Shdr * sechdr) 282 { 283 long ret; 284 285 ret = ALIGN(*size, sechdr->sh_addralign ? : 1); 286 *size = ret + sechdr->sh_size; 287 return ret; 288 } 289 290 /* Lay out the SHF_ALLOC sections in a way not dissimilar to how ld 291 might -- code, read-only data, read-write data, small data. Tally 292 sizes, and place the offsets into sh_entsize fields: high bit means it 293 belongs in init. */ 294 static void layout_sections(struct module *mod, const Elf_Ehdr * hdr, 295 Elf_Shdr * sechdrs, const char *secstrings) 296 { 297 static unsigned long const masks[][2] = { 298 /* NOTE: all executable code must be the first section 299 * in this array; otherwise modify the text_size 300 * finder in the two loops below */ 301 {SHF_EXECINSTR | SHF_ALLOC, ARCH_SHF_SMALL}, 302 {SHF_ALLOC, SHF_WRITE | ARCH_SHF_SMALL}, 303 {SHF_WRITE | SHF_ALLOC, ARCH_SHF_SMALL}, 304 {ARCH_SHF_SMALL | SHF_ALLOC, 0} 305 }; 306 unsigned int m, i; 307 308 for (i = 0; i < hdr->e_shnum; i++) 309 sechdrs[i].sh_entsize = ~0UL; 310 311 for (m = 0; m < ARRAY_SIZE(masks); ++m) { 312 for (i = 0; i < hdr->e_shnum; ++i) { 313 Elf_Shdr *s = &sechdrs[i]; 314 315 // || strncmp(secstrings + s->sh_name, ".init", 5) == 0) 316 if ((s->sh_flags & masks[m][0]) != masks[m][0] 317 || (s->sh_flags & masks[m][1]) 318 || s->sh_entsize != ~0UL) 319 continue; 320 s->sh_entsize = get_offset(&mod->core_size, s); 321 } 322 323 if (m == 0) 324 mod->core_text_size = mod->core_size; 325 326 } 327 } 328 329 330 /* from module-elf32.c, but subverted a little */ 331 332 struct mips_hi16 { 333 struct mips_hi16 *next; 334 Elf32_Addr *addr; 335 Elf32_Addr value; 336 }; 337 338 static struct mips_hi16 *mips_hi16_list; 339 static unsigned int gp_offs, gp_addr; 340 341 static int apply_r_mips_none(struct module *me, uint32_t *location, 342 Elf32_Addr v) 343 { 344 return 0; 345 } 346 347 static int apply_r_mips_gprel16(struct module *me, uint32_t *location, 348 Elf32_Addr v) 349 { 350 int rel; 351 352 if( !(*location & 0xffff) ) { 353 rel = (int)v - gp_addr; 354 } 355 else { 356 /* .sbss + gp(relative) + offset */ 357 /* kludge! */ 358 rel = (int)(short)((int)v + gp_offs + 359 (int)(short)(*location & 0xffff) - gp_addr); 360 } 361 362 if( (rel > 32768) || (rel < -32768) ) { 363 printk(KERN_DEBUG "VPE loader: apply_r_mips_gprel16: " 364 "relative address 0x%x out of range of gp register\n", 365 rel); 366 return -ENOEXEC; 367 } 368 369 *location = (*location & 0xffff0000) | (rel & 0xffff); 370 371 return 0; 372 } 373 374 static int apply_r_mips_pc16(struct module *me, uint32_t *location, 375 Elf32_Addr v) 376 { 377 int rel; 378 rel = (((unsigned int)v - (unsigned int)location)); 379 rel >>= 2; // because the offset is in _instructions_ not bytes. 380 rel -= 1; // and one instruction less due to the branch delay slot. 381 382 if( (rel > 32768) || (rel < -32768) ) { 383 printk(KERN_DEBUG "VPE loader: " 384 "apply_r_mips_pc16: relative address out of range 0x%x\n", rel); 385 return -ENOEXEC; 386 } 387 388 *location = (*location & 0xffff0000) | (rel & 0xffff); 389 390 return 0; 391 } 392 393 static int apply_r_mips_32(struct module *me, uint32_t *location, 394 Elf32_Addr v) 395 { 396 *location += v; 397 398 return 0; 399 } 400 401 static int apply_r_mips_26(struct module *me, uint32_t *location, 402 Elf32_Addr v) 403 { 404 if (v % 4) { 405 printk(KERN_DEBUG "VPE loader: apply_r_mips_26 " 406 " unaligned relocation\n"); 407 return -ENOEXEC; 408 } 409 410 /* 411 * Not desperately convinced this is a good check of an overflow condition 412 * anyway. But it gets in the way of handling undefined weak symbols which 413 * we want to set to zero. 414 * if ((v & 0xf0000000) != (((unsigned long)location + 4) & 0xf0000000)) { 415 * printk(KERN_ERR 416 * "module %s: relocation overflow\n", 417 * me->name); 418 * return -ENOEXEC; 419 * } 420 */ 421 422 *location = (*location & ~0x03ffffff) | 423 ((*location + (v >> 2)) & 0x03ffffff); 424 return 0; 425 } 426 427 static int apply_r_mips_hi16(struct module *me, uint32_t *location, 428 Elf32_Addr v) 429 { 430 struct mips_hi16 *n; 431 432 /* 433 * We cannot relocate this one now because we don't know the value of 434 * the carry we need to add. Save the information, and let LO16 do the 435 * actual relocation. 436 */ 437 n = kmalloc(sizeof *n, GFP_KERNEL); 438 if (!n) 439 return -ENOMEM; 440 441 n->addr = location; 442 n->value = v; 443 n->next = mips_hi16_list; 444 mips_hi16_list = n; 445 446 return 0; 447 } 448 449 static int apply_r_mips_lo16(struct module *me, uint32_t *location, 450 Elf32_Addr v) 451 { 452 unsigned long insnlo = *location; 453 Elf32_Addr val, vallo; 454 455 /* Sign extend the addend we extract from the lo insn. */ 456 vallo = ((insnlo & 0xffff) ^ 0x8000) - 0x8000; 457 458 if (mips_hi16_list != NULL) { 459 struct mips_hi16 *l; 460 461 l = mips_hi16_list; 462 while (l != NULL) { 463 struct mips_hi16 *next; 464 unsigned long insn; 465 466 /* 467 * The value for the HI16 had best be the same. 468 */ 469 if (v != l->value) { 470 printk(KERN_DEBUG "VPE loader: " 471 "apply_r_mips_lo16/hi16: " 472 "inconsistent value information\n"); 473 return -ENOEXEC; 474 } 475 476 /* 477 * Do the HI16 relocation. Note that we actually don't 478 * need to know anything about the LO16 itself, except 479 * where to find the low 16 bits of the addend needed 480 * by the LO16. 481 */ 482 insn = *l->addr; 483 val = ((insn & 0xffff) << 16) + vallo; 484 val += v; 485 486 /* 487 * Account for the sign extension that will happen in 488 * the low bits. 489 */ 490 val = ((val >> 16) + ((val & 0x8000) != 0)) & 0xffff; 491 492 insn = (insn & ~0xffff) | val; 493 *l->addr = insn; 494 495 next = l->next; 496 kfree(l); 497 l = next; 498 } 499 500 mips_hi16_list = NULL; 501 } 502 503 /* 504 * Ok, we're done with the HI16 relocs. Now deal with the LO16. 505 */ 506 val = v + vallo; 507 insnlo = (insnlo & ~0xffff) | (val & 0xffff); 508 *location = insnlo; 509 510 return 0; 511 } 512 513 static int (*reloc_handlers[]) (struct module *me, uint32_t *location, 514 Elf32_Addr v) = { 515 [R_MIPS_NONE] = apply_r_mips_none, 516 [R_MIPS_32] = apply_r_mips_32, 517 [R_MIPS_26] = apply_r_mips_26, 518 [R_MIPS_HI16] = apply_r_mips_hi16, 519 [R_MIPS_LO16] = apply_r_mips_lo16, 520 [R_MIPS_GPREL16] = apply_r_mips_gprel16, 521 [R_MIPS_PC16] = apply_r_mips_pc16 522 }; 523 524 static char *rstrs[] = { 525 [R_MIPS_NONE] = "MIPS_NONE", 526 [R_MIPS_32] = "MIPS_32", 527 [R_MIPS_26] = "MIPS_26", 528 [R_MIPS_HI16] = "MIPS_HI16", 529 [R_MIPS_LO16] = "MIPS_LO16", 530 [R_MIPS_GPREL16] = "MIPS_GPREL16", 531 [R_MIPS_PC16] = "MIPS_PC16" 532 }; 533 534 int apply_relocations(Elf32_Shdr *sechdrs, 535 const char *strtab, 536 unsigned int symindex, 537 unsigned int relsec, 538 struct module *me) 539 { 540 Elf32_Rel *rel = (void *) sechdrs[relsec].sh_addr; 541 Elf32_Sym *sym; 542 uint32_t *location; 543 unsigned int i; 544 Elf32_Addr v; 545 int res; 546 547 for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) { 548 Elf32_Word r_info = rel[i].r_info; 549 550 /* This is where to make the change */ 551 location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr 552 + rel[i].r_offset; 553 /* This is the symbol it is referring to */ 554 sym = (Elf32_Sym *)sechdrs[symindex].sh_addr 555 + ELF32_R_SYM(r_info); 556 557 if (!sym->st_value) { 558 printk(KERN_DEBUG "%s: undefined weak symbol %s\n", 559 me->name, strtab + sym->st_name); 560 /* just print the warning, dont barf */ 561 } 562 563 v = sym->st_value; 564 565 res = reloc_handlers[ELF32_R_TYPE(r_info)](me, location, v); 566 if( res ) { 567 char *r = rstrs[ELF32_R_TYPE(r_info)]; 568 printk(KERN_WARNING "VPE loader: .text+0x%x " 569 "relocation type %s for symbol \"%s\" failed\n", 570 rel[i].r_offset, r ? r : "UNKNOWN", 571 strtab + sym->st_name); 572 return res; 573 } 574 } 575 576 return 0; 577 } 578 579 void save_gp_address(unsigned int secbase, unsigned int rel) 580 { 581 gp_addr = secbase + rel; 582 gp_offs = gp_addr - (secbase & 0xffff0000); 583 } 584 /* end module-elf32.c */ 585 586 587 588 /* Change all symbols so that sh_value encodes the pointer directly. */ 589 static void simplify_symbols(Elf_Shdr * sechdrs, 590 unsigned int symindex, 591 const char *strtab, 592 const char *secstrings, 593 unsigned int nsecs, struct module *mod) 594 { 595 Elf_Sym *sym = (void *)sechdrs[symindex].sh_addr; 596 unsigned long secbase, bssbase = 0; 597 unsigned int i, n = sechdrs[symindex].sh_size / sizeof(Elf_Sym); 598 int size; 599 600 /* find the .bss section for COMMON symbols */ 601 for (i = 0; i < nsecs; i++) { 602 if (strncmp(secstrings + sechdrs[i].sh_name, ".bss", 4) == 0) { 603 bssbase = sechdrs[i].sh_addr; 604 break; 605 } 606 } 607 608 for (i = 1; i < n; i++) { 609 switch (sym[i].st_shndx) { 610 case SHN_COMMON: 611 /* Allocate space for the symbol in the .bss section. 612 st_value is currently size. 613 We want it to have the address of the symbol. */ 614 615 size = sym[i].st_value; 616 sym[i].st_value = bssbase; 617 618 bssbase += size; 619 break; 620 621 case SHN_ABS: 622 /* Don't need to do anything */ 623 break; 624 625 case SHN_UNDEF: 626 /* ret = -ENOENT; */ 627 break; 628 629 case SHN_MIPS_SCOMMON: 630 printk(KERN_DEBUG "simplify_symbols: ignoring SHN_MIPS_SCOMMON" 631 "symbol <%s> st_shndx %d\n", strtab + sym[i].st_name, 632 sym[i].st_shndx); 633 // .sbss section 634 break; 635 636 default: 637 secbase = sechdrs[sym[i].st_shndx].sh_addr; 638 639 if (strncmp(strtab + sym[i].st_name, "_gp", 3) == 0) { 640 save_gp_address(secbase, sym[i].st_value); 641 } 642 643 sym[i].st_value += secbase; 644 break; 645 } 646 } 647 } 648 649 #ifdef DEBUG_ELFLOADER 650 static void dump_elfsymbols(Elf_Shdr * sechdrs, unsigned int symindex, 651 const char *strtab, struct module *mod) 652 { 653 Elf_Sym *sym = (void *)sechdrs[symindex].sh_addr; 654 unsigned int i, n = sechdrs[symindex].sh_size / sizeof(Elf_Sym); 655 656 printk(KERN_DEBUG "dump_elfsymbols: n %d\n", n); 657 for (i = 1; i < n; i++) { 658 printk(KERN_DEBUG " i %d name <%s> 0x%x\n", i, 659 strtab + sym[i].st_name, sym[i].st_value); 660 } 661 } 662 #endif 663 664 static void dump_tc(struct tc *t) 665 { 666 unsigned long val; 667 668 settc(t->index); 669 printk(KERN_DEBUG "VPE loader: TC index %d targtc %ld " 670 "TCStatus 0x%lx halt 0x%lx\n", 671 t->index, read_c0_vpecontrol() & VPECONTROL_TARGTC, 672 read_tc_c0_tcstatus(), read_tc_c0_tchalt()); 673 674 printk(KERN_DEBUG " tcrestart 0x%lx\n", read_tc_c0_tcrestart()); 675 printk(KERN_DEBUG " tcbind 0x%lx\n", read_tc_c0_tcbind()); 676 677 val = read_c0_vpeconf0(); 678 printk(KERN_DEBUG " VPEConf0 0x%lx MVP %ld\n", val, 679 (val & VPECONF0_MVP) >> VPECONF0_MVP_SHIFT); 680 681 printk(KERN_DEBUG " c0 status 0x%lx\n", read_vpe_c0_status()); 682 printk(KERN_DEBUG " c0 cause 0x%lx\n", read_vpe_c0_cause()); 683 684 printk(KERN_DEBUG " c0 badvaddr 0x%lx\n", read_vpe_c0_badvaddr()); 685 printk(KERN_DEBUG " c0 epc 0x%lx\n", read_vpe_c0_epc()); 686 } 687 688 static void dump_tclist(void) 689 { 690 struct tc *t; 691 692 list_for_each_entry(t, &vpecontrol.tc_list, list) { 693 dump_tc(t); 694 } 695 } 696 697 /* We are prepared so configure and start the VPE... */ 698 static int vpe_run(struct vpe * v) 699 { 700 struct vpe_notifications *n; 701 unsigned long val, dmt_flag; 702 struct tc *t; 703 704 /* check we are the Master VPE */ 705 val = read_c0_vpeconf0(); 706 if (!(val & VPECONF0_MVP)) { 707 printk(KERN_WARNING 708 "VPE loader: only Master VPE's are allowed to configure MT\n"); 709 return -1; 710 } 711 712 /* disable MT (using dvpe) */ 713 dvpe(); 714 715 if (!list_empty(&v->tc)) { 716 if ((t = list_entry(v->tc.next, struct tc, tc)) == NULL) { 717 printk(KERN_WARNING "VPE loader: TC %d is already in use.\n", 718 t->index); 719 return -ENOEXEC; 720 } 721 } else { 722 printk(KERN_WARNING "VPE loader: No TC's associated with VPE %d\n", 723 v->minor); 724 return -ENOEXEC; 725 } 726 727 /* Put MVPE's into 'configuration state' */ 728 set_c0_mvpcontrol(MVPCONTROL_VPC); 729 730 settc(t->index); 731 732 /* should check it is halted, and not activated */ 733 if ((read_tc_c0_tcstatus() & TCSTATUS_A) || !(read_tc_c0_tchalt() & TCHALT_H)) { 734 printk(KERN_WARNING "VPE loader: TC %d is already doing something!\n", 735 t->index); 736 dump_tclist(); 737 return -ENOEXEC; 738 } 739 740 /* 741 * Disable multi-threaded execution whilst we activate, clear the 742 * halt bit and bound the tc to the other VPE... 743 */ 744 dmt_flag = dmt(); 745 746 /* Write the address we want it to start running from in the TCPC register. */ 747 write_tc_c0_tcrestart((unsigned long)v->__start); 748 write_tc_c0_tccontext((unsigned long)0); 749 /* 750 * Mark the TC as activated, not interrupt exempt and not dynamically 751 * allocatable 752 */ 753 val = read_tc_c0_tcstatus(); 754 val = (val & ~(TCSTATUS_DA | TCSTATUS_IXMT)) | TCSTATUS_A; 755 write_tc_c0_tcstatus(val); 756 757 write_tc_c0_tchalt(read_tc_c0_tchalt() & ~TCHALT_H); 758 759 /* 760 * The sde-kit passes 'memsize' to __start in $a3, so set something 761 * here... Or set $a3 to zero and define DFLT_STACK_SIZE and 762 * DFLT_HEAP_SIZE when you compile your program 763 */ 764 mttgpr(7, physical_memsize); 765 766 767 /* set up VPE1 */ 768 /* 769 * bind the TC to VPE 1 as late as possible so we only have the final 770 * VPE registers to set up, and so an EJTAG probe can trigger on it 771 */ 772 write_tc_c0_tcbind((read_tc_c0_tcbind() & ~TCBIND_CURVPE) | v->minor); 773 774 write_vpe_c0_vpeconf0(read_vpe_c0_vpeconf0() & ~(VPECONF0_VPA)); 775 776 back_to_back_c0_hazard(); 777 778 /* Set up the XTC bit in vpeconf0 to point at our tc */ 779 write_vpe_c0_vpeconf0( (read_vpe_c0_vpeconf0() & ~(VPECONF0_XTC)) 780 | (t->index << VPECONF0_XTC_SHIFT)); 781 782 back_to_back_c0_hazard(); 783 784 /* enable this VPE */ 785 write_vpe_c0_vpeconf0(read_vpe_c0_vpeconf0() | VPECONF0_VPA); 786 787 /* clear out any left overs from a previous program */ 788 write_vpe_c0_status(0); 789 write_vpe_c0_cause(0); 790 791 /* take system out of configuration state */ 792 clear_c0_mvpcontrol(MVPCONTROL_VPC); 793 794 /* now safe to re-enable multi-threading */ 795 emt(dmt_flag); 796 797 /* set it running */ 798 evpe(EVPE_ENABLE); 799 800 list_for_each_entry(n, &v->notify, list) { 801 n->start(v->minor); 802 } 803 804 return 0; 805 } 806 807 static int find_vpe_symbols(struct vpe * v, Elf_Shdr * sechdrs, 808 unsigned int symindex, const char *strtab, 809 struct module *mod) 810 { 811 Elf_Sym *sym = (void *)sechdrs[symindex].sh_addr; 812 unsigned int i, n = sechdrs[symindex].sh_size / sizeof(Elf_Sym); 813 814 for (i = 1; i < n; i++) { 815 if (strcmp(strtab + sym[i].st_name, "__start") == 0) { 816 v->__start = sym[i].st_value; 817 } 818 819 if (strcmp(strtab + sym[i].st_name, "vpe_shared") == 0) { 820 v->shared_ptr = (void *)sym[i].st_value; 821 } 822 } 823 824 if ( (v->__start == 0) || (v->shared_ptr == NULL)) 825 return -1; 826 827 return 0; 828 } 829 830 /* 831 * Allocates a VPE with some program code space(the load address), copies the 832 * contents of the program (p)buffer performing relocatations/etc, free's it 833 * when finished. 834 */ 835 static int vpe_elfload(struct vpe * v) 836 { 837 Elf_Ehdr *hdr; 838 Elf_Shdr *sechdrs; 839 long err = 0; 840 char *secstrings, *strtab = NULL; 841 unsigned int len, i, symindex = 0, strindex = 0, relocate = 0; 842 struct module mod; // so we can re-use the relocations code 843 844 memset(&mod, 0, sizeof(struct module)); 845 strcpy(mod.name, "VPE loader"); 846 847 hdr = (Elf_Ehdr *) v->pbuffer; 848 len = v->plen; 849 850 /* Sanity checks against insmoding binaries or wrong arch, 851 weird elf version */ 852 if (memcmp(hdr->e_ident, ELFMAG, 4) != 0 853 || (hdr->e_type != ET_REL && hdr->e_type != ET_EXEC) 854 || !elf_check_arch(hdr) 855 || hdr->e_shentsize != sizeof(*sechdrs)) { 856 printk(KERN_WARNING 857 "VPE loader: program wrong arch or weird elf version\n"); 858 859 return -ENOEXEC; 860 } 861 862 if (hdr->e_type == ET_REL) 863 relocate = 1; 864 865 if (len < hdr->e_shoff + hdr->e_shnum * sizeof(Elf_Shdr)) { 866 printk(KERN_ERR "VPE loader: program length %u truncated\n", 867 len); 868 869 return -ENOEXEC; 870 } 871 872 /* Convenience variables */ 873 sechdrs = (void *)hdr + hdr->e_shoff; 874 secstrings = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset; 875 sechdrs[0].sh_addr = 0; 876 877 /* And these should exist, but gcc whinges if we don't init them */ 878 symindex = strindex = 0; 879 880 if (relocate) { 881 for (i = 1; i < hdr->e_shnum; i++) { 882 if (sechdrs[i].sh_type != SHT_NOBITS 883 && len < sechdrs[i].sh_offset + sechdrs[i].sh_size) { 884 printk(KERN_ERR "VPE program length %u truncated\n", 885 len); 886 return -ENOEXEC; 887 } 888 889 /* Mark all sections sh_addr with their address in the 890 temporary image. */ 891 sechdrs[i].sh_addr = (size_t) hdr + sechdrs[i].sh_offset; 892 893 /* Internal symbols and strings. */ 894 if (sechdrs[i].sh_type == SHT_SYMTAB) { 895 symindex = i; 896 strindex = sechdrs[i].sh_link; 897 strtab = (char *)hdr + sechdrs[strindex].sh_offset; 898 } 899 } 900 layout_sections(&mod, hdr, sechdrs, secstrings); 901 } 902 903 v->load_addr = alloc_progmem(mod.core_size); 904 memset(v->load_addr, 0, mod.core_size); 905 906 printk("VPE loader: loading to %p\n", v->load_addr); 907 908 if (relocate) { 909 for (i = 0; i < hdr->e_shnum; i++) { 910 void *dest; 911 912 if (!(sechdrs[i].sh_flags & SHF_ALLOC)) 913 continue; 914 915 dest = v->load_addr + sechdrs[i].sh_entsize; 916 917 if (sechdrs[i].sh_type != SHT_NOBITS) 918 memcpy(dest, (void *)sechdrs[i].sh_addr, 919 sechdrs[i].sh_size); 920 /* Update sh_addr to point to copy in image. */ 921 sechdrs[i].sh_addr = (unsigned long)dest; 922 923 printk(KERN_DEBUG " section sh_name %s sh_addr 0x%x\n", 924 secstrings + sechdrs[i].sh_name, sechdrs[i].sh_addr); 925 } 926 927 /* Fix up syms, so that st_value is a pointer to location. */ 928 simplify_symbols(sechdrs, symindex, strtab, secstrings, 929 hdr->e_shnum, &mod); 930 931 /* Now do relocations. */ 932 for (i = 1; i < hdr->e_shnum; i++) { 933 const char *strtab = (char *)sechdrs[strindex].sh_addr; 934 unsigned int info = sechdrs[i].sh_info; 935 936 /* Not a valid relocation section? */ 937 if (info >= hdr->e_shnum) 938 continue; 939 940 /* Don't bother with non-allocated sections */ 941 if (!(sechdrs[info].sh_flags & SHF_ALLOC)) 942 continue; 943 944 if (sechdrs[i].sh_type == SHT_REL) 945 err = apply_relocations(sechdrs, strtab, symindex, i, 946 &mod); 947 else if (sechdrs[i].sh_type == SHT_RELA) 948 err = apply_relocate_add(sechdrs, strtab, symindex, i, 949 &mod); 950 if (err < 0) 951 return err; 952 953 } 954 } else { 955 for (i = 0; i < hdr->e_shnum; i++) { 956 957 /* Internal symbols and strings. */ 958 if (sechdrs[i].sh_type == SHT_SYMTAB) { 959 symindex = i; 960 strindex = sechdrs[i].sh_link; 961 strtab = (char *)hdr + sechdrs[strindex].sh_offset; 962 963 /* mark the symtab's address for when we try to find the 964 magic symbols */ 965 sechdrs[i].sh_addr = (size_t) hdr + sechdrs[i].sh_offset; 966 } 967 968 /* filter sections we dont want in the final image */ 969 if (!(sechdrs[i].sh_flags & SHF_ALLOC) || 970 (sechdrs[i].sh_type == SHT_MIPS_REGINFO)) { 971 printk( KERN_DEBUG " ignoring section, " 972 "name %s type %x address 0x%x \n", 973 secstrings + sechdrs[i].sh_name, 974 sechdrs[i].sh_type, sechdrs[i].sh_addr); 975 continue; 976 } 977 978 if (sechdrs[i].sh_addr < (unsigned int)v->load_addr) { 979 printk( KERN_WARNING "VPE loader: " 980 "fully linked image has invalid section, " 981 "name %s type %x address 0x%x, before load " 982 "address of 0x%x\n", 983 secstrings + sechdrs[i].sh_name, 984 sechdrs[i].sh_type, sechdrs[i].sh_addr, 985 (unsigned int)v->load_addr); 986 return -ENOEXEC; 987 } 988 989 printk(KERN_DEBUG " copying section sh_name %s, sh_addr 0x%x " 990 "size 0x%x0 from x%p\n", 991 secstrings + sechdrs[i].sh_name, sechdrs[i].sh_addr, 992 sechdrs[i].sh_size, hdr + sechdrs[i].sh_offset); 993 994 if (sechdrs[i].sh_type != SHT_NOBITS) 995 memcpy((void *)sechdrs[i].sh_addr, 996 (char *)hdr + sechdrs[i].sh_offset, 997 sechdrs[i].sh_size); 998 else 999 memset((void *)sechdrs[i].sh_addr, 0, sechdrs[i].sh_size); 1000 } 1001 } 1002 1003 /* make sure it's physically written out */ 1004 flush_icache_range((unsigned long)v->load_addr, 1005 (unsigned long)v->load_addr + v->len); 1006 1007 if ((find_vpe_symbols(v, sechdrs, symindex, strtab, &mod)) < 0) { 1008 if (v->__start == 0) { 1009 printk(KERN_WARNING "VPE loader: program does not contain " 1010 "a __start symbol\n"); 1011 return -ENOEXEC; 1012 } 1013 1014 if (v->shared_ptr == NULL) 1015 printk(KERN_WARNING "VPE loader: " 1016 "program does not contain vpe_shared symbol.\n" 1017 " Unable to use AMVP (AP/SP) facilities.\n"); 1018 } 1019 1020 printk(" elf loaded\n"); 1021 return 0; 1022 } 1023 1024 __attribute_used__ void dump_vpe(struct vpe * v) 1025 { 1026 struct tc *t; 1027 1028 settc(v->minor); 1029 1030 printk(KERN_DEBUG "VPEControl 0x%lx\n", read_vpe_c0_vpecontrol()); 1031 printk(KERN_DEBUG "VPEConf0 0x%lx\n", read_vpe_c0_vpeconf0()); 1032 1033 list_for_each_entry(t, &vpecontrol.tc_list, list) 1034 dump_tc(t); 1035 } 1036 1037 static void cleanup_tc(struct tc *tc) 1038 { 1039 int tmp; 1040 1041 /* Put MVPE's into 'configuration state' */ 1042 set_c0_mvpcontrol(MVPCONTROL_VPC); 1043 1044 settc(tc->index); 1045 tmp = read_tc_c0_tcstatus(); 1046 1047 /* mark not allocated and not dynamically allocatable */ 1048 tmp &= ~(TCSTATUS_A | TCSTATUS_DA); 1049 tmp |= TCSTATUS_IXMT; /* interrupt exempt */ 1050 write_tc_c0_tcstatus(tmp); 1051 1052 write_tc_c0_tchalt(TCHALT_H); 1053 1054 /* bind it to anything other than VPE1 */ 1055 write_tc_c0_tcbind(read_tc_c0_tcbind() & ~TCBIND_CURVPE); // | TCBIND_CURVPE 1056 1057 clear_c0_mvpcontrol(MVPCONTROL_VPC); 1058 } 1059 1060 static int getcwd(char *buff, int size) 1061 { 1062 mm_segment_t old_fs; 1063 int ret; 1064 1065 old_fs = get_fs(); 1066 set_fs(KERNEL_DS); 1067 1068 ret = sys_getcwd(buff,size); 1069 1070 set_fs(old_fs); 1071 1072 return ret; 1073 } 1074 1075 /* checks VPE is unused and gets ready to load program */ 1076 static int vpe_open(struct inode *inode, struct file *filp) 1077 { 1078 int minor, ret; 1079 struct vpe *v; 1080 struct vpe_notifications *not; 1081 1082 /* assume only 1 device at the mo. */ 1083 if ((minor = iminor(inode)) != 1) { 1084 printk(KERN_WARNING "VPE loader: only vpe1 is supported\n"); 1085 return -ENODEV; 1086 } 1087 1088 if ((v = get_vpe(minor)) == NULL) { 1089 printk(KERN_WARNING "VPE loader: unable to get vpe\n"); 1090 return -ENODEV; 1091 } 1092 1093 if (v->state != VPE_STATE_UNUSED) { 1094 dvpe(); 1095 1096 printk(KERN_DEBUG "VPE loader: tc in use dumping regs\n"); 1097 1098 dump_tc(get_tc(minor)); 1099 1100 list_for_each_entry(not, &v->notify, list) { 1101 not->stop(minor); 1102 } 1103 1104 release_progmem(v->load_addr); 1105 cleanup_tc(get_tc(minor)); 1106 } 1107 1108 // allocate it so when we get write ops we know it's expected. 1109 v->state = VPE_STATE_INUSE; 1110 1111 /* this of-course trashes what was there before... */ 1112 v->pbuffer = vmalloc(P_SIZE); 1113 v->plen = P_SIZE; 1114 v->load_addr = NULL; 1115 v->len = 0; 1116 1117 v->uid = filp->f_uid; 1118 v->gid = filp->f_gid; 1119 1120 #ifdef CONFIG_MIPS_APSP_KSPD 1121 /* get kspd to tell us when a syscall_exit happens */ 1122 if (!kspd_events_reqd) { 1123 kspd_notify(&kspd_events); 1124 kspd_events_reqd++; 1125 } 1126 #endif 1127 1128 v->cwd[0] = 0; 1129 ret = getcwd(v->cwd, VPE_PATH_MAX); 1130 if (ret < 0) 1131 printk(KERN_WARNING "VPE loader: open, getcwd returned %d\n", ret); 1132 1133 v->shared_ptr = NULL; 1134 v->__start = 0; 1135 return 0; 1136 } 1137 1138 static int vpe_release(struct inode *inode, struct file *filp) 1139 { 1140 int minor, ret = 0; 1141 struct vpe *v; 1142 Elf_Ehdr *hdr; 1143 1144 minor = iminor(inode); 1145 if ((v = get_vpe(minor)) == NULL) 1146 return -ENODEV; 1147 1148 // simple case of fire and forget, so tell the VPE to run... 1149 1150 hdr = (Elf_Ehdr *) v->pbuffer; 1151 if (memcmp(hdr->e_ident, ELFMAG, 4) == 0) { 1152 if (vpe_elfload(v) >= 0) 1153 vpe_run(v); 1154 else { 1155 printk(KERN_WARNING "VPE loader: ELF load failed.\n"); 1156 ret = -ENOEXEC; 1157 } 1158 } else { 1159 printk(KERN_WARNING "VPE loader: only elf files are supported\n"); 1160 ret = -ENOEXEC; 1161 } 1162 1163 /* It's good to be able to run the SP and if it chokes have a look at 1164 the /dev/rt?. But if we reset the pointer to the shared struct we 1165 loose what has happened. So perhaps if garbage is sent to the vpe 1166 device, use it as a trigger for the reset. Hopefully a nice 1167 executable will be along shortly. */ 1168 if (ret < 0) 1169 v->shared_ptr = NULL; 1170 1171 // cleanup any temp buffers 1172 if (v->pbuffer) 1173 vfree(v->pbuffer); 1174 v->plen = 0; 1175 return ret; 1176 } 1177 1178 static ssize_t vpe_write(struct file *file, const char __user * buffer, 1179 size_t count, loff_t * ppos) 1180 { 1181 int minor; 1182 size_t ret = count; 1183 struct vpe *v; 1184 1185 minor = iminor(file->f_path.dentry->d_inode); 1186 if ((v = get_vpe(minor)) == NULL) 1187 return -ENODEV; 1188 1189 if (v->pbuffer == NULL) { 1190 printk(KERN_ERR "VPE loader: no buffer for program\n"); 1191 return -ENOMEM; 1192 } 1193 1194 if ((count + v->len) > v->plen) { 1195 printk(KERN_WARNING 1196 "VPE loader: elf size too big. Perhaps strip uneeded symbols\n"); 1197 return -ENOMEM; 1198 } 1199 1200 count -= copy_from_user(v->pbuffer + v->len, buffer, count); 1201 if (!count) 1202 return -EFAULT; 1203 1204 v->len += count; 1205 return ret; 1206 } 1207 1208 static struct file_operations vpe_fops = { 1209 .owner = THIS_MODULE, 1210 .open = vpe_open, 1211 .release = vpe_release, 1212 .write = vpe_write 1213 }; 1214 1215 /* module wrapper entry points */ 1216 /* give me a vpe */ 1217 vpe_handle vpe_alloc(void) 1218 { 1219 int i; 1220 struct vpe *v; 1221 1222 /* find a vpe */ 1223 for (i = 1; i < MAX_VPES; i++) { 1224 if ((v = get_vpe(i)) != NULL) { 1225 v->state = VPE_STATE_INUSE; 1226 return v; 1227 } 1228 } 1229 return NULL; 1230 } 1231 1232 EXPORT_SYMBOL(vpe_alloc); 1233 1234 /* start running from here */ 1235 int vpe_start(vpe_handle vpe, unsigned long start) 1236 { 1237 struct vpe *v = vpe; 1238 1239 v->__start = start; 1240 return vpe_run(v); 1241 } 1242 1243 EXPORT_SYMBOL(vpe_start); 1244 1245 /* halt it for now */ 1246 int vpe_stop(vpe_handle vpe) 1247 { 1248 struct vpe *v = vpe; 1249 struct tc *t; 1250 unsigned int evpe_flags; 1251 1252 evpe_flags = dvpe(); 1253 1254 if ((t = list_entry(v->tc.next, struct tc, tc)) != NULL) { 1255 1256 settc(t->index); 1257 write_vpe_c0_vpeconf0(read_vpe_c0_vpeconf0() & ~VPECONF0_VPA); 1258 } 1259 1260 evpe(evpe_flags); 1261 1262 return 0; 1263 } 1264 1265 EXPORT_SYMBOL(vpe_stop); 1266 1267 /* I've done with it thank you */ 1268 int vpe_free(vpe_handle vpe) 1269 { 1270 struct vpe *v = vpe; 1271 struct tc *t; 1272 unsigned int evpe_flags; 1273 1274 if ((t = list_entry(v->tc.next, struct tc, tc)) == NULL) { 1275 return -ENOEXEC; 1276 } 1277 1278 evpe_flags = dvpe(); 1279 1280 /* Put MVPE's into 'configuration state' */ 1281 set_c0_mvpcontrol(MVPCONTROL_VPC); 1282 1283 settc(t->index); 1284 write_vpe_c0_vpeconf0(read_vpe_c0_vpeconf0() & ~VPECONF0_VPA); 1285 1286 /* mark the TC unallocated and halt'ed */ 1287 write_tc_c0_tcstatus(read_tc_c0_tcstatus() & ~TCSTATUS_A); 1288 write_tc_c0_tchalt(TCHALT_H); 1289 1290 v->state = VPE_STATE_UNUSED; 1291 1292 clear_c0_mvpcontrol(MVPCONTROL_VPC); 1293 evpe(evpe_flags); 1294 1295 return 0; 1296 } 1297 1298 EXPORT_SYMBOL(vpe_free); 1299 1300 void *vpe_get_shared(int index) 1301 { 1302 struct vpe *v; 1303 1304 if ((v = get_vpe(index)) == NULL) 1305 return NULL; 1306 1307 return v->shared_ptr; 1308 } 1309 1310 EXPORT_SYMBOL(vpe_get_shared); 1311 1312 int vpe_getuid(int index) 1313 { 1314 struct vpe *v; 1315 1316 if ((v = get_vpe(index)) == NULL) 1317 return -1; 1318 1319 return v->uid; 1320 } 1321 1322 EXPORT_SYMBOL(vpe_getuid); 1323 1324 int vpe_getgid(int index) 1325 { 1326 struct vpe *v; 1327 1328 if ((v = get_vpe(index)) == NULL) 1329 return -1; 1330 1331 return v->gid; 1332 } 1333 1334 EXPORT_SYMBOL(vpe_getgid); 1335 1336 int vpe_notify(int index, struct vpe_notifications *notify) 1337 { 1338 struct vpe *v; 1339 1340 if ((v = get_vpe(index)) == NULL) 1341 return -1; 1342 1343 list_add(¬ify->list, &v->notify); 1344 return 0; 1345 } 1346 1347 EXPORT_SYMBOL(vpe_notify); 1348 1349 char *vpe_getcwd(int index) 1350 { 1351 struct vpe *v; 1352 1353 if ((v = get_vpe(index)) == NULL) 1354 return NULL; 1355 1356 return v->cwd; 1357 } 1358 1359 EXPORT_SYMBOL(vpe_getcwd); 1360 1361 #ifdef CONFIG_MIPS_APSP_KSPD 1362 static void kspd_sp_exit( int sp_id) 1363 { 1364 cleanup_tc(get_tc(sp_id)); 1365 } 1366 #endif 1367 1368 static int __init vpe_module_init(void) 1369 { 1370 struct vpe *v = NULL; 1371 struct tc *t; 1372 unsigned long val; 1373 int i; 1374 1375 if (!cpu_has_mipsmt) { 1376 printk("VPE loader: not a MIPS MT capable processor\n"); 1377 return -ENODEV; 1378 } 1379 1380 major = register_chrdev(0, module_name, &vpe_fops); 1381 if (major < 0) { 1382 printk("VPE loader: unable to register character device\n"); 1383 return major; 1384 } 1385 1386 dmt(); 1387 dvpe(); 1388 1389 /* Put MVPE's into 'configuration state' */ 1390 set_c0_mvpcontrol(MVPCONTROL_VPC); 1391 1392 /* dump_mtregs(); */ 1393 1394 1395 val = read_c0_mvpconf0(); 1396 for (i = 0; i < ((val & MVPCONF0_PTC) + 1); i++) { 1397 t = alloc_tc(i); 1398 1399 /* VPE's */ 1400 if (i < ((val & MVPCONF0_PVPE) >> MVPCONF0_PVPE_SHIFT) + 1) { 1401 settc(i); 1402 1403 if ((v = alloc_vpe(i)) == NULL) { 1404 printk(KERN_WARNING "VPE: unable to allocate VPE\n"); 1405 return -ENODEV; 1406 } 1407 1408 /* add the tc to the list of this vpe's tc's. */ 1409 list_add(&t->tc, &v->tc); 1410 1411 /* deactivate all but vpe0 */ 1412 if (i != 0) { 1413 unsigned long tmp = read_vpe_c0_vpeconf0(); 1414 1415 tmp &= ~VPECONF0_VPA; 1416 1417 /* master VPE */ 1418 tmp |= VPECONF0_MVP; 1419 write_vpe_c0_vpeconf0(tmp); 1420 } 1421 1422 /* disable multi-threading with TC's */ 1423 write_vpe_c0_vpecontrol(read_vpe_c0_vpecontrol() & ~VPECONTROL_TE); 1424 1425 if (i != 0) { 1426 write_vpe_c0_status((read_c0_status() & 1427 ~(ST0_IM | ST0_IE | ST0_KSU)) 1428 | ST0_CU0); 1429 1430 /* 1431 * Set config to be the same as vpe0, 1432 * particularly kseg0 coherency alg 1433 */ 1434 write_vpe_c0_config(read_c0_config()); 1435 } 1436 } 1437 1438 /* TC's */ 1439 t->pvpe = v; /* set the parent vpe */ 1440 1441 if (i != 0) { 1442 unsigned long tmp; 1443 1444 settc(i); 1445 1446 /* Any TC that is bound to VPE0 gets left as is - in case 1447 we are running SMTC on VPE0. A TC that is bound to any 1448 other VPE gets bound to VPE0, ideally I'd like to make 1449 it homeless but it doesn't appear to let me bind a TC 1450 to a non-existent VPE. Which is perfectly reasonable. 1451 1452 The (un)bound state is visible to an EJTAG probe so may 1453 notify GDB... 1454 */ 1455 1456 if (((tmp = read_tc_c0_tcbind()) & TCBIND_CURVPE)) { 1457 /* tc is bound >vpe0 */ 1458 write_tc_c0_tcbind(tmp & ~TCBIND_CURVPE); 1459 1460 t->pvpe = get_vpe(0); /* set the parent vpe */ 1461 } 1462 1463 tmp = read_tc_c0_tcstatus(); 1464 1465 /* mark not activated and not dynamically allocatable */ 1466 tmp &= ~(TCSTATUS_A | TCSTATUS_DA); 1467 tmp |= TCSTATUS_IXMT; /* interrupt exempt */ 1468 write_tc_c0_tcstatus(tmp); 1469 1470 write_tc_c0_tchalt(TCHALT_H); 1471 } 1472 } 1473 1474 /* release config state */ 1475 clear_c0_mvpcontrol(MVPCONTROL_VPC); 1476 1477 #ifdef CONFIG_MIPS_APSP_KSPD 1478 kspd_events.kspd_sp_exit = kspd_sp_exit; 1479 #endif 1480 return 0; 1481 } 1482 1483 static void __exit vpe_module_exit(void) 1484 { 1485 struct vpe *v, *n; 1486 1487 list_for_each_entry_safe(v, n, &vpecontrol.vpe_list, list) { 1488 if (v->state != VPE_STATE_UNUSED) { 1489 release_vpe(v); 1490 } 1491 } 1492 1493 unregister_chrdev(major, module_name); 1494 } 1495 1496 module_init(vpe_module_init); 1497 module_exit(vpe_module_exit); 1498 MODULE_DESCRIPTION("MIPS VPE Loader"); 1499 MODULE_AUTHOR("Elizabeth Oldham, MIPS Technologies, Inc."); 1500 MODULE_LICENSE("GPL"); 1501