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