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