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