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