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