Pileus Git - ~andy/linux/blob - arch/mips/kernel/vpe.c

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