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