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