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