blob: 3ca5f42e819dc3ab4a6793510216d38218b6bc72 [file] [log] [blame]
Ralf Baechlee01402b2005-07-14 15:57:16 +00001/*
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.
Ralf Baechlee01402b2005-07-14 15:57:16 +000016 */
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.
Ralf Baechlee01402b2005-07-14 15:57:16 +000029 */
Ralf Baechlee01402b2005-07-14 15:57:16 +000030#include <linux/kernel.h>
Ralf Baechle27a3bba2007-02-07 13:48:59 +000031#include <linux/device.h>
Ralf Baechlee01402b2005-07-14 15:57:16 +000032#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>
Jonathan Corbet7558da92008-05-15 09:10:50 -060041#include <linux/smp_lock.h>
Ralf Baechlee01402b2005-07-14 15:57:16 +000042#include <linux/syscalls.h>
43#include <linux/moduleloader.h>
44#include <linux/interrupt.h>
45#include <linux/poll.h>
46#include <linux/bootmem.h>
47#include <asm/mipsregs.h>
Ralf Baechle340ee4b2005-08-17 17:44:08 +000048#include <asm/mipsmtregs.h>
Ralf Baechlee01402b2005-07-14 15:57:16 +000049#include <asm/cacheflush.h>
50#include <asm/atomic.h>
51#include <asm/cpu.h>
Ralf Baechle27a3bba2007-02-07 13:48:59 +000052#include <asm/mips_mt.h>
Ralf Baechlee01402b2005-07-14 15:57:16 +000053#include <asm/processor.h>
54#include <asm/system.h>
Ralf Baechle26009902006-04-05 09:45:45 +010055#include <asm/vpe.h>
56#include <asm/kspd.h>
Ralf Baechlee01402b2005-07-14 15:57:16 +000057
58typedef void *vpe_handle;
59
Ralf Baechlee01402b2005-07-14 15:57:16 +000060#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
Ralf Baechle41790e02007-07-27 19:33:18 +010067/*
68 * The number of TCs and VPEs physically available on the core
69 */
70static int hw_tcs, hw_vpes;
Ralf Baechlee01402b2005-07-14 15:57:16 +000071static char module_name[] = "vpe";
Ralf Baechle307bd282005-10-31 23:34:52 +000072static int major;
Ralf Baechle27a3bba2007-02-07 13:48:59 +000073static const int minor = 1; /* fixed for now */
Ralf Baechlee01402b2005-07-14 15:57:16 +000074
Ralf Baechle26009902006-04-05 09:45:45 +010075#ifdef CONFIG_MIPS_APSP_KSPD
76 static struct kspd_notifications kspd_events;
77static int kspd_events_reqd = 0;
78#endif
79
Ralf Baechlee01402b2005-07-14 15:57:16 +000080/* 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
Ralf Baechle26009902006-04-05 09:45:45 +010088extern unsigned long physical_memsize;
89
Ralf Baechlee01402b2005-07-14 15:57:16 +000090#define MAX_VPES 16
Ralf Baechle26009902006-04-05 09:45:45 +010091#define VPE_PATH_MAX 256
Ralf Baechlee01402b2005-07-14 15:57:16 +000092
93enum vpe_state {
94 VPE_STATE_UNUSED = 0,
95 VPE_STATE_INUSE,
96 VPE_STATE_RUNNING
97};
98
99enum tc_state {
100 TC_STATE_UNUSED = 0,
101 TC_STATE_INUSE,
102 TC_STATE_RUNNING,
103 TC_STATE_DYNAMIC
104};
105
Ralf Baechle307bd282005-10-31 23:34:52 +0000106struct vpe {
Ralf Baechlee01402b2005-07-14 15:57:16 +0000107 enum vpe_state state;
108
109 /* (device) minor associated with this vpe */
110 int minor;
111
112 /* elfloader stuff */
113 void *load_addr;
Ralf Baechle571e0be2005-12-08 00:32:23 +0000114 unsigned long len;
Ralf Baechlee01402b2005-07-14 15:57:16 +0000115 char *pbuffer;
Ralf Baechle571e0be2005-12-08 00:32:23 +0000116 unsigned long plen;
Ralf Baechle26009902006-04-05 09:45:45 +0100117 unsigned int uid, gid;
118 char cwd[VPE_PATH_MAX];
Ralf Baechlee01402b2005-07-14 15:57:16 +0000119
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;
Ralf Baechle26009902006-04-05 09:45:45 +0100130
131 /* the list of who wants to know when something major happens */
132 struct list_head notify;
Ralf Baechle41790e02007-07-27 19:33:18 +0100133
134 unsigned int ntcs;
Ralf Baechle307bd282005-10-31 23:34:52 +0000135};
136
137struct tc {
138 enum tc_state state;
139 int index;
140
Ralf Baechle07cc0c92007-07-27 19:31:10 +0100141 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 */
Ralf Baechle307bd282005-10-31 23:34:52 +0000144};
Ralf Baechlee01402b2005-07-14 15:57:16 +0000145
Ralf Baechle9cfdf6f2007-01-24 19:13:08 +0000146struct {
Ralf Baechlee01402b2005-07-14 15:57:16 +0000147 /* Virtual processing elements */
148 struct list_head vpe_list;
149
150 /* Thread contexts */
151 struct list_head tc_list;
Ralf Baechle9cfdf6f2007-01-24 19:13:08 +0000152} vpecontrol = {
153 .vpe_list = LIST_HEAD_INIT(vpecontrol.vpe_list),
154 .tc_list = LIST_HEAD_INIT(vpecontrol.tc_list)
155};
Ralf Baechlee01402b2005-07-14 15:57:16 +0000156
157static void release_progmem(void *ptr);
Ralf Baechlee01402b2005-07-14 15:57:16 +0000158extern void save_gp_address(unsigned int secbase, unsigned int rel);
159
160/* get the vpe associated with this minor */
161struct vpe *get_vpe(int minor)
162{
163 struct vpe *v;
164
Ralf Baechle26009902006-04-05 09:45:45 +0100165 if (!cpu_has_mipsmt)
166 return NULL;
167
Ralf Baechlee01402b2005-07-14 15:57:16 +0000168 list_for_each_entry(v, &vpecontrol.vpe_list, list) {
169 if (v->minor == minor)
170 return v;
171 }
172
Ralf Baechlee01402b2005-07-14 15:57:16 +0000173 return NULL;
174}
175
176/* get the vpe associated with this minor */
177struct 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
Ralf Baechlee01402b2005-07-14 15:57:16 +0000186 return NULL;
187}
188
189struct 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
Ralf Baechlee01402b2005-07-14 15:57:16 +0000198 return NULL;
199}
200
201/* allocate a vpe and associate it with this minor (or index) */
202struct vpe *alloc_vpe(int minor)
203{
204 struct vpe *v;
205
Ralf Baechle307bd282005-10-31 23:34:52 +0000206 if ((v = kzalloc(sizeof(struct vpe), GFP_KERNEL)) == NULL) {
Ralf Baechlee01402b2005-07-14 15:57:16 +0000207 return NULL;
208 }
209
Ralf Baechlee01402b2005-07-14 15:57:16 +0000210 INIT_LIST_HEAD(&v->tc);
211 list_add_tail(&v->list, &vpecontrol.vpe_list);
212
Ralf Baechle26009902006-04-05 09:45:45 +0100213 INIT_LIST_HEAD(&v->notify);
Ralf Baechlee01402b2005-07-14 15:57:16 +0000214 v->minor = minor;
215 return v;
216}
217
218/* allocate a tc. At startup only tc0 is running, all other can be halted. */
219struct tc *alloc_tc(int index)
220{
Ralf Baechle07cc0c92007-07-27 19:31:10 +0100221 struct tc *tc;
Ralf Baechlee01402b2005-07-14 15:57:16 +0000222
Ralf Baechle07cc0c92007-07-27 19:31:10 +0100223 if ((tc = kzalloc(sizeof(struct tc), GFP_KERNEL)) == NULL)
224 goto out;
Ralf Baechlee01402b2005-07-14 15:57:16 +0000225
Ralf Baechle07cc0c92007-07-27 19:31:10 +0100226 INIT_LIST_HEAD(&tc->tc);
227 tc->index = index;
228 list_add_tail(&tc->list, &vpecontrol.tc_list);
Ralf Baechlee01402b2005-07-14 15:57:16 +0000229
Ralf Baechle07cc0c92007-07-27 19:31:10 +0100230out:
231 return tc;
Ralf Baechlee01402b2005-07-14 15:57:16 +0000232}
233
234/* clean up and free everything */
235void 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
243void 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
Ralf Baechlee01402b2005-07-14 15:57:16 +0000251 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
Ralf Baechle26009902006-04-05 09:45:45 +0100257 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);
Ralf Baechlee01402b2005-07-14 15:57:16 +0000261}
262
263/* Find some VPE program space */
Ralf Baechle571e0be2005-12-08 00:32:23 +0000264static void *alloc_progmem(unsigned long len)
Ralf Baechlee01402b2005-07-14 15:57:16 +0000265{
Ralf Baechle5408c492008-03-13 15:16:53 +0000266 void *addr;
267
Ralf Baechlee01402b2005-07-14 15:57:16 +0000268#ifdef CONFIG_MIPS_VPE_LOADER_TOM
Ralf Baechle5408c492008-03-13 15:16:53 +0000269 /*
270 * This means you must tell Linux to use less memory than you
271 * physically have, for example by passing a mem= boot argument.
272 */
Ralf Baechle9f2546a2008-04-17 13:42:50 +0100273 addr = pfn_to_kaddr(max_low_pfn);
Ralf Baechle5408c492008-03-13 15:16:53 +0000274 memset(addr, 0, len);
Ralf Baechlee01402b2005-07-14 15:57:16 +0000275#else
Ralf Baechle5408c492008-03-13 15:16:53 +0000276 /* simple grab some mem for now */
277 addr = kzalloc(len, GFP_KERNEL);
Ralf Baechlee01402b2005-07-14 15:57:16 +0000278#endif
Ralf Baechle5408c492008-03-13 15:16:53 +0000279
280 return addr;
Ralf Baechlee01402b2005-07-14 15:57:16 +0000281}
282
283static void release_progmem(void *ptr)
284{
285#ifndef CONFIG_MIPS_VPE_LOADER_TOM
286 kfree(ptr);
287#endif
288}
289
290/* Update size with this section: return offset. */
291static long get_offset(unsigned long *size, Elf_Shdr * sechdr)
292{
293 long ret;
294
295 ret = ALIGN(*size, sechdr->sh_addralign ? : 1);
296 *size = ret + sechdr->sh_size;
297 return ret;
298}
299
300/* Lay out the SHF_ALLOC sections in a way not dissimilar to how ld
301 might -- code, read-only data, read-write data, small data. Tally
302 sizes, and place the offsets into sh_entsize fields: high bit means it
303 belongs in init. */
304static void layout_sections(struct module *mod, const Elf_Ehdr * hdr,
305 Elf_Shdr * sechdrs, const char *secstrings)
306{
307 static unsigned long const masks[][2] = {
308 /* NOTE: all executable code must be the first section
309 * in this array; otherwise modify the text_size
310 * finder in the two loops below */
311 {SHF_EXECINSTR | SHF_ALLOC, ARCH_SHF_SMALL},
312 {SHF_ALLOC, SHF_WRITE | ARCH_SHF_SMALL},
313 {SHF_WRITE | SHF_ALLOC, ARCH_SHF_SMALL},
314 {ARCH_SHF_SMALL | SHF_ALLOC, 0}
315 };
316 unsigned int m, i;
317
318 for (i = 0; i < hdr->e_shnum; i++)
319 sechdrs[i].sh_entsize = ~0UL;
320
321 for (m = 0; m < ARRAY_SIZE(masks); ++m) {
322 for (i = 0; i < hdr->e_shnum; ++i) {
323 Elf_Shdr *s = &sechdrs[i];
324
325 // || strncmp(secstrings + s->sh_name, ".init", 5) == 0)
326 if ((s->sh_flags & masks[m][0]) != masks[m][0]
327 || (s->sh_flags & masks[m][1])
328 || s->sh_entsize != ~0UL)
329 continue;
330 s->sh_entsize = get_offset(&mod->core_size, s);
331 }
332
333 if (m == 0)
334 mod->core_text_size = mod->core_size;
335
336 }
337}
338
339
340/* from module-elf32.c, but subverted a little */
341
342struct mips_hi16 {
343 struct mips_hi16 *next;
344 Elf32_Addr *addr;
345 Elf32_Addr value;
346};
347
348static struct mips_hi16 *mips_hi16_list;
349static unsigned int gp_offs, gp_addr;
350
351static int apply_r_mips_none(struct module *me, uint32_t *location,
352 Elf32_Addr v)
353{
354 return 0;
355}
356
357static int apply_r_mips_gprel16(struct module *me, uint32_t *location,
358 Elf32_Addr v)
359{
360 int rel;
361
362 if( !(*location & 0xffff) ) {
363 rel = (int)v - gp_addr;
364 }
365 else {
366 /* .sbss + gp(relative) + offset */
367 /* kludge! */
368 rel = (int)(short)((int)v + gp_offs +
369 (int)(short)(*location & 0xffff) - gp_addr);
370 }
371
372 if( (rel > 32768) || (rel < -32768) ) {
Ralf Baechle26009902006-04-05 09:45:45 +0100373 printk(KERN_DEBUG "VPE loader: apply_r_mips_gprel16: "
374 "relative address 0x%x out of range of gp register\n",
375 rel);
Ralf Baechlee01402b2005-07-14 15:57:16 +0000376 return -ENOEXEC;
377 }
378
379 *location = (*location & 0xffff0000) | (rel & 0xffff);
380
381 return 0;
382}
383
384static int apply_r_mips_pc16(struct module *me, uint32_t *location,
385 Elf32_Addr v)
386{
387 int rel;
388 rel = (((unsigned int)v - (unsigned int)location));
389 rel >>= 2; // because the offset is in _instructions_ not bytes.
390 rel -= 1; // and one instruction less due to the branch delay slot.
391
392 if( (rel > 32768) || (rel < -32768) ) {
Ralf Baechle26009902006-04-05 09:45:45 +0100393 printk(KERN_DEBUG "VPE loader: "
394 "apply_r_mips_pc16: relative address out of range 0x%x\n", rel);
Ralf Baechlee01402b2005-07-14 15:57:16 +0000395 return -ENOEXEC;
396 }
397
398 *location = (*location & 0xffff0000) | (rel & 0xffff);
399
400 return 0;
401}
402
403static int apply_r_mips_32(struct module *me, uint32_t *location,
404 Elf32_Addr v)
405{
406 *location += v;
407
408 return 0;
409}
410
411static int apply_r_mips_26(struct module *me, uint32_t *location,
412 Elf32_Addr v)
413{
414 if (v % 4) {
Ralf Baechle26009902006-04-05 09:45:45 +0100415 printk(KERN_DEBUG "VPE loader: apply_r_mips_26 "
416 " unaligned relocation\n");
Ralf Baechlee01402b2005-07-14 15:57:16 +0000417 return -ENOEXEC;
418 }
419
Ralf Baechle307bd282005-10-31 23:34:52 +0000420/*
421 * Not desperately convinced this is a good check of an overflow condition
422 * anyway. But it gets in the way of handling undefined weak symbols which
423 * we want to set to zero.
424 * if ((v & 0xf0000000) != (((unsigned long)location + 4) & 0xf0000000)) {
425 * printk(KERN_ERR
426 * "module %s: relocation overflow\n",
427 * me->name);
428 * return -ENOEXEC;
429 * }
430 */
Ralf Baechlee01402b2005-07-14 15:57:16 +0000431
432 *location = (*location & ~0x03ffffff) |
433 ((*location + (v >> 2)) & 0x03ffffff);
434 return 0;
435}
436
437static int apply_r_mips_hi16(struct module *me, uint32_t *location,
438 Elf32_Addr v)
439{
440 struct mips_hi16 *n;
441
442 /*
443 * We cannot relocate this one now because we don't know the value of
444 * the carry we need to add. Save the information, and let LO16 do the
445 * actual relocation.
446 */
447 n = kmalloc(sizeof *n, GFP_KERNEL);
448 if (!n)
449 return -ENOMEM;
450
451 n->addr = location;
452 n->value = v;
453 n->next = mips_hi16_list;
454 mips_hi16_list = n;
455
456 return 0;
457}
458
459static int apply_r_mips_lo16(struct module *me, uint32_t *location,
460 Elf32_Addr v)
461{
462 unsigned long insnlo = *location;
463 Elf32_Addr val, vallo;
464
465 /* Sign extend the addend we extract from the lo insn. */
466 vallo = ((insnlo & 0xffff) ^ 0x8000) - 0x8000;
467
468 if (mips_hi16_list != NULL) {
469 struct mips_hi16 *l;
470
471 l = mips_hi16_list;
472 while (l != NULL) {
473 struct mips_hi16 *next;
474 unsigned long insn;
475
476 /*
477 * The value for the HI16 had best be the same.
478 */
Ralf Baechle26009902006-04-05 09:45:45 +0100479 if (v != l->value) {
480 printk(KERN_DEBUG "VPE loader: "
Joe Perchesb1e3afa2007-11-19 17:47:54 -0800481 "apply_r_mips_lo16/hi16: \t"
Ralf Baechle26009902006-04-05 09:45:45 +0100482 "inconsistent value information\n");
483 return -ENOEXEC;
Ralf Baechlee01402b2005-07-14 15:57:16 +0000484 }
485
Ralf Baechlee01402b2005-07-14 15:57:16 +0000486 /*
487 * Do the HI16 relocation. Note that we actually don't
488 * need to know anything about the LO16 itself, except
489 * where to find the low 16 bits of the addend needed
490 * by the LO16.
491 */
492 insn = *l->addr;
493 val = ((insn & 0xffff) << 16) + vallo;
494 val += v;
495
496 /*
497 * Account for the sign extension that will happen in
498 * the low bits.
499 */
500 val = ((val >> 16) + ((val & 0x8000) != 0)) & 0xffff;
501
502 insn = (insn & ~0xffff) | val;
503 *l->addr = insn;
504
505 next = l->next;
506 kfree(l);
507 l = next;
508 }
509
510 mips_hi16_list = NULL;
511 }
512
513 /*
514 * Ok, we're done with the HI16 relocs. Now deal with the LO16.
515 */
516 val = v + vallo;
517 insnlo = (insnlo & ~0xffff) | (val & 0xffff);
518 *location = insnlo;
519
520 return 0;
Ralf Baechlee01402b2005-07-14 15:57:16 +0000521}
522
523static int (*reloc_handlers[]) (struct module *me, uint32_t *location,
524 Elf32_Addr v) = {
525 [R_MIPS_NONE] = apply_r_mips_none,
526 [R_MIPS_32] = apply_r_mips_32,
527 [R_MIPS_26] = apply_r_mips_26,
528 [R_MIPS_HI16] = apply_r_mips_hi16,
529 [R_MIPS_LO16] = apply_r_mips_lo16,
530 [R_MIPS_GPREL16] = apply_r_mips_gprel16,
531 [R_MIPS_PC16] = apply_r_mips_pc16
532};
533
Ralf Baechle26009902006-04-05 09:45:45 +0100534static char *rstrs[] = {
Ralf Baechlee0daad42007-02-05 00:10:11 +0000535 [R_MIPS_NONE] = "MIPS_NONE",
Ralf Baechle26009902006-04-05 09:45:45 +0100536 [R_MIPS_32] = "MIPS_32",
537 [R_MIPS_26] = "MIPS_26",
538 [R_MIPS_HI16] = "MIPS_HI16",
539 [R_MIPS_LO16] = "MIPS_LO16",
540 [R_MIPS_GPREL16] = "MIPS_GPREL16",
541 [R_MIPS_PC16] = "MIPS_PC16"
542};
Ralf Baechlee01402b2005-07-14 15:57:16 +0000543
544int apply_relocations(Elf32_Shdr *sechdrs,
545 const char *strtab,
546 unsigned int symindex,
547 unsigned int relsec,
548 struct module *me)
549{
550 Elf32_Rel *rel = (void *) sechdrs[relsec].sh_addr;
551 Elf32_Sym *sym;
552 uint32_t *location;
553 unsigned int i;
554 Elf32_Addr v;
555 int res;
556
557 for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {
558 Elf32_Word r_info = rel[i].r_info;
559
560 /* This is where to make the change */
561 location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr
562 + rel[i].r_offset;
563 /* This is the symbol it is referring to */
564 sym = (Elf32_Sym *)sechdrs[symindex].sh_addr
565 + ELF32_R_SYM(r_info);
566
567 if (!sym->st_value) {
568 printk(KERN_DEBUG "%s: undefined weak symbol %s\n",
569 me->name, strtab + sym->st_name);
570 /* just print the warning, dont barf */
571 }
572
573 v = sym->st_value;
574
575 res = reloc_handlers[ELF32_R_TYPE(r_info)](me, location, v);
576 if( res ) {
Ralf Baechle26009902006-04-05 09:45:45 +0100577 char *r = rstrs[ELF32_R_TYPE(r_info)];
578 printk(KERN_WARNING "VPE loader: .text+0x%x "
579 "relocation type %s for symbol \"%s\" failed\n",
580 rel[i].r_offset, r ? r : "UNKNOWN",
581 strtab + sym->st_name);
Ralf Baechlee01402b2005-07-14 15:57:16 +0000582 return res;
Ralf Baechle26009902006-04-05 09:45:45 +0100583 }
Ralf Baechlee01402b2005-07-14 15:57:16 +0000584 }
585
586 return 0;
587}
588
589void save_gp_address(unsigned int secbase, unsigned int rel)
590{
591 gp_addr = secbase + rel;
592 gp_offs = gp_addr - (secbase & 0xffff0000);
593}
594/* end module-elf32.c */
595
596
597
598/* Change all symbols so that sh_value encodes the pointer directly. */
Ralf Baechle26009902006-04-05 09:45:45 +0100599static void simplify_symbols(Elf_Shdr * sechdrs,
Ralf Baechlee01402b2005-07-14 15:57:16 +0000600 unsigned int symindex,
601 const char *strtab,
602 const char *secstrings,
603 unsigned int nsecs, struct module *mod)
604{
605 Elf_Sym *sym = (void *)sechdrs[symindex].sh_addr;
606 unsigned long secbase, bssbase = 0;
607 unsigned int i, n = sechdrs[symindex].sh_size / sizeof(Elf_Sym);
Ralf Baechle26009902006-04-05 09:45:45 +0100608 int size;
Ralf Baechlee01402b2005-07-14 15:57:16 +0000609
610 /* find the .bss section for COMMON symbols */
611 for (i = 0; i < nsecs; i++) {
Ralf Baechle26009902006-04-05 09:45:45 +0100612 if (strncmp(secstrings + sechdrs[i].sh_name, ".bss", 4) == 0) {
Ralf Baechlee01402b2005-07-14 15:57:16 +0000613 bssbase = sechdrs[i].sh_addr;
Ralf Baechle26009902006-04-05 09:45:45 +0100614 break;
615 }
Ralf Baechlee01402b2005-07-14 15:57:16 +0000616 }
617
618 for (i = 1; i < n; i++) {
619 switch (sym[i].st_shndx) {
620 case SHN_COMMON:
Ralf Baechle26009902006-04-05 09:45:45 +0100621 /* Allocate space for the symbol in the .bss section.
622 st_value is currently size.
Ralf Baechlee01402b2005-07-14 15:57:16 +0000623 We want it to have the address of the symbol. */
624
625 size = sym[i].st_value;
626 sym[i].st_value = bssbase;
627
628 bssbase += size;
629 break;
630
631 case SHN_ABS:
632 /* Don't need to do anything */
633 break;
634
635 case SHN_UNDEF:
636 /* ret = -ENOENT; */
637 break;
638
639 case SHN_MIPS_SCOMMON:
Joe Perchesb1e3afa2007-11-19 17:47:54 -0800640 printk(KERN_DEBUG "simplify_symbols: ignoring SHN_MIPS_SCOMMON "
Ralf Baechle26009902006-04-05 09:45:45 +0100641 "symbol <%s> st_shndx %d\n", strtab + sym[i].st_name,
642 sym[i].st_shndx);
Ralf Baechlee01402b2005-07-14 15:57:16 +0000643 // .sbss section
644 break;
645
646 default:
647 secbase = sechdrs[sym[i].st_shndx].sh_addr;
648
649 if (strncmp(strtab + sym[i].st_name, "_gp", 3) == 0) {
650 save_gp_address(secbase, sym[i].st_value);
651 }
652
653 sym[i].st_value += secbase;
654 break;
655 }
Ralf Baechlee01402b2005-07-14 15:57:16 +0000656 }
Ralf Baechlee01402b2005-07-14 15:57:16 +0000657}
658
659#ifdef DEBUG_ELFLOADER
660static void dump_elfsymbols(Elf_Shdr * sechdrs, unsigned int symindex,
661 const char *strtab, struct module *mod)
662{
663 Elf_Sym *sym = (void *)sechdrs[symindex].sh_addr;
664 unsigned int i, n = sechdrs[symindex].sh_size / sizeof(Elf_Sym);
665
666 printk(KERN_DEBUG "dump_elfsymbols: n %d\n", n);
667 for (i = 1; i < n; i++) {
668 printk(KERN_DEBUG " i %d name <%s> 0x%x\n", i,
669 strtab + sym[i].st_name, sym[i].st_value);
670 }
671}
672#endif
673
Ralf Baechlee01402b2005-07-14 15:57:16 +0000674/* We are prepared so configure and start the VPE... */
Ralf Baechlebe6e1432007-02-06 16:53:17 +0000675static int vpe_run(struct vpe * v)
Ralf Baechlee01402b2005-07-14 15:57:16 +0000676{
Ralf Baechle07cc0c92007-07-27 19:31:10 +0100677 unsigned long flags, val, dmt_flag;
Ralf Baechle26009902006-04-05 09:45:45 +0100678 struct vpe_notifications *n;
Ralf Baechle07cc0c92007-07-27 19:31:10 +0100679 unsigned int vpeflags;
Ralf Baechlee01402b2005-07-14 15:57:16 +0000680 struct tc *t;
681
682 /* check we are the Master VPE */
Ralf Baechle07cc0c92007-07-27 19:31:10 +0100683 local_irq_save(flags);
Ralf Baechlee01402b2005-07-14 15:57:16 +0000684 val = read_c0_vpeconf0();
685 if (!(val & VPECONF0_MVP)) {
686 printk(KERN_WARNING
Ralf Baechle26009902006-04-05 09:45:45 +0100687 "VPE loader: only Master VPE's are allowed to configure MT\n");
Ralf Baechle07cc0c92007-07-27 19:31:10 +0100688 local_irq_restore(flags);
689
Ralf Baechlee01402b2005-07-14 15:57:16 +0000690 return -1;
691 }
692
Ralf Baechle07cc0c92007-07-27 19:31:10 +0100693 dmt_flag = dmt();
694 vpeflags = dvpe();
Ralf Baechlee01402b2005-07-14 15:57:16 +0000695
Ralf Baechle26009902006-04-05 09:45:45 +0100696 if (!list_empty(&v->tc)) {
Ralf Baechlee0daad42007-02-05 00:10:11 +0000697 if ((t = list_entry(v->tc.next, struct tc, tc)) == NULL) {
Ralf Baechle07cc0c92007-07-27 19:31:10 +0100698 evpe(vpeflags);
699 emt(dmt_flag);
700 local_irq_restore(flags);
701
702 printk(KERN_WARNING
703 "VPE loader: TC %d is already in use.\n",
704 t->index);
Ralf Baechlee0daad42007-02-05 00:10:11 +0000705 return -ENOEXEC;
706 }
707 } else {
Ralf Baechle07cc0c92007-07-27 19:31:10 +0100708 evpe(vpeflags);
709 emt(dmt_flag);
710 local_irq_restore(flags);
711
712 printk(KERN_WARNING
713 "VPE loader: No TC's associated with VPE %d\n",
Ralf Baechlee0daad42007-02-05 00:10:11 +0000714 v->minor);
Ralf Baechle07cc0c92007-07-27 19:31:10 +0100715
Ralf Baechlee0daad42007-02-05 00:10:11 +0000716 return -ENOEXEC;
717 }
Ralf Baechle26009902006-04-05 09:45:45 +0100718
Ralf Baechlee01402b2005-07-14 15:57:16 +0000719 /* Put MVPE's into 'configuration state' */
Ralf Baechle340ee4b2005-08-17 17:44:08 +0000720 set_c0_mvpcontrol(MVPCONTROL_VPC);
Ralf Baechlee01402b2005-07-14 15:57:16 +0000721
Ralf Baechlee01402b2005-07-14 15:57:16 +0000722 settc(t->index);
723
Ralf Baechlee01402b2005-07-14 15:57:16 +0000724 /* should check it is halted, and not activated */
725 if ((read_tc_c0_tcstatus() & TCSTATUS_A) || !(read_tc_c0_tchalt() & TCHALT_H)) {
Ralf Baechle07cc0c92007-07-27 19:31:10 +0100726 evpe(vpeflags);
727 emt(dmt_flag);
728 local_irq_restore(flags);
729
730 printk(KERN_WARNING "VPE loader: TC %d is already active!\n",
Ralf Baechlee01402b2005-07-14 15:57:16 +0000731 t->index);
Ralf Baechle07cc0c92007-07-27 19:31:10 +0100732
Ralf Baechlee01402b2005-07-14 15:57:16 +0000733 return -ENOEXEC;
734 }
735
736 /* Write the address we want it to start running from in the TCPC register. */
737 write_tc_c0_tcrestart((unsigned long)v->__start);
Ralf Baechlee01402b2005-07-14 15:57:16 +0000738 write_tc_c0_tccontext((unsigned long)0);
Ralf Baechle07cc0c92007-07-27 19:31:10 +0100739
Ralf Baechle26009902006-04-05 09:45:45 +0100740 /*
741 * Mark the TC as activated, not interrupt exempt and not dynamically
742 * allocatable
743 */
Ralf Baechlee01402b2005-07-14 15:57:16 +0000744 val = read_tc_c0_tcstatus();
745 val = (val & ~(TCSTATUS_DA | TCSTATUS_IXMT)) | TCSTATUS_A;
746 write_tc_c0_tcstatus(val);
747
748 write_tc_c0_tchalt(read_tc_c0_tchalt() & ~TCHALT_H);
749
Ralf Baechlee01402b2005-07-14 15:57:16 +0000750 /*
751 * The sde-kit passes 'memsize' to __start in $a3, so set something
Ralf Baechle26009902006-04-05 09:45:45 +0100752 * here... Or set $a3 to zero and define DFLT_STACK_SIZE and
Ralf Baechlee01402b2005-07-14 15:57:16 +0000753 * DFLT_HEAP_SIZE when you compile your program
754 */
Ralf Baechle41790e02007-07-27 19:33:18 +0100755 mttgpr(6, v->ntcs);
Ralf Baechle07cc0c92007-07-27 19:31:10 +0100756 mttgpr(7, physical_memsize);
Ralf Baechlee01402b2005-07-14 15:57:16 +0000757
Ralf Baechle26009902006-04-05 09:45:45 +0100758 /* set up VPE1 */
759 /*
760 * bind the TC to VPE 1 as late as possible so we only have the final
761 * VPE registers to set up, and so an EJTAG probe can trigger on it
762 */
Ralf Baechle07cc0c92007-07-27 19:31:10 +0100763 write_tc_c0_tcbind((read_tc_c0_tcbind() & ~TCBIND_CURVPE) | 1);
Ralf Baechle26009902006-04-05 09:45:45 +0100764
Elizabeth Oldhama94d7022006-08-17 12:39:21 +0100765 write_vpe_c0_vpeconf0(read_vpe_c0_vpeconf0() & ~(VPECONF0_VPA));
766
767 back_to_back_c0_hazard();
768
Ralf Baechlee0daad42007-02-05 00:10:11 +0000769 /* Set up the XTC bit in vpeconf0 to point at our tc */
770 write_vpe_c0_vpeconf0( (read_vpe_c0_vpeconf0() & ~(VPECONF0_XTC))
771 | (t->index << VPECONF0_XTC_SHIFT));
Ralf Baechle26009902006-04-05 09:45:45 +0100772
Elizabeth Oldhama94d7022006-08-17 12:39:21 +0100773 back_to_back_c0_hazard();
774
Ralf Baechlee0daad42007-02-05 00:10:11 +0000775 /* enable this VPE */
776 write_vpe_c0_vpeconf0(read_vpe_c0_vpeconf0() | VPECONF0_VPA);
Ralf Baechlee01402b2005-07-14 15:57:16 +0000777
778 /* clear out any left overs from a previous program */
Ralf Baechle26009902006-04-05 09:45:45 +0100779 write_vpe_c0_status(0);
Ralf Baechlee01402b2005-07-14 15:57:16 +0000780 write_vpe_c0_cause(0);
781
782 /* take system out of configuration state */
Ralf Baechle340ee4b2005-08-17 17:44:08 +0000783 clear_c0_mvpcontrol(MVPCONTROL_VPC);
Ralf Baechlee01402b2005-07-14 15:57:16 +0000784
Kevin D. Kissellb6183362008-04-16 15:32:22 +0200785 /*
786 * SMTC/SMVP kernels manage VPE enable independently,
787 * but uniprocessor kernels need to turn it on, even
788 * if that wasn't the pre-dvpe() state.
789 */
Ralf Baechle07cc0c92007-07-27 19:31:10 +0100790#ifdef CONFIG_SMP
Ralf Baechle07cc0c92007-07-27 19:31:10 +0100791 evpe(vpeflags);
Kevin D. Kissellb6183362008-04-16 15:32:22 +0200792#else
793 evpe(EVPE_ENABLE);
Ralf Baechle07cc0c92007-07-27 19:31:10 +0100794#endif
795 emt(dmt_flag);
796 local_irq_restore(flags);
Ralf Baechlee01402b2005-07-14 15:57:16 +0000797
Ralf Baechle07cc0c92007-07-27 19:31:10 +0100798 list_for_each_entry(n, &v->notify, list)
799 n->start(minor);
Ralf Baechle26009902006-04-05 09:45:45 +0100800
Ralf Baechlee01402b2005-07-14 15:57:16 +0000801 return 0;
802}
803
Ralf Baechle26009902006-04-05 09:45:45 +0100804static int find_vpe_symbols(struct vpe * v, Elf_Shdr * sechdrs,
Ralf Baechlee01402b2005-07-14 15:57:16 +0000805 unsigned int symindex, const char *strtab,
806 struct module *mod)
807{
808 Elf_Sym *sym = (void *)sechdrs[symindex].sh_addr;
809 unsigned int i, n = sechdrs[symindex].sh_size / sizeof(Elf_Sym);
810
811 for (i = 1; i < n; i++) {
812 if (strcmp(strtab + sym[i].st_name, "__start") == 0) {
813 v->__start = sym[i].st_value;
814 }
815
816 if (strcmp(strtab + sym[i].st_name, "vpe_shared") == 0) {
817 v->shared_ptr = (void *)sym[i].st_value;
818 }
819 }
820
Ralf Baechle26009902006-04-05 09:45:45 +0100821 if ( (v->__start == 0) || (v->shared_ptr == NULL))
822 return -1;
823
Ralf Baechlee01402b2005-07-14 15:57:16 +0000824 return 0;
825}
826
Ralf Baechle307bd282005-10-31 23:34:52 +0000827/*
Ralf Baechle26009902006-04-05 09:45:45 +0100828 * Allocates a VPE with some program code space(the load address), copies the
829 * contents of the program (p)buffer performing relocatations/etc, free's it
830 * when finished.
831 */
Ralf Baechlebe6e1432007-02-06 16:53:17 +0000832static int vpe_elfload(struct vpe * v)
Ralf Baechlee01402b2005-07-14 15:57:16 +0000833{
834 Elf_Ehdr *hdr;
835 Elf_Shdr *sechdrs;
836 long err = 0;
837 char *secstrings, *strtab = NULL;
Ralf Baechle26009902006-04-05 09:45:45 +0100838 unsigned int len, i, symindex = 0, strindex = 0, relocate = 0;
Ralf Baechlee01402b2005-07-14 15:57:16 +0000839 struct module mod; // so we can re-use the relocations code
840
841 memset(&mod, 0, sizeof(struct module));
Ralf Baechle26009902006-04-05 09:45:45 +0100842 strcpy(mod.name, "VPE loader");
Ralf Baechlee01402b2005-07-14 15:57:16 +0000843
844 hdr = (Elf_Ehdr *) v->pbuffer;
845 len = v->plen;
846
847 /* Sanity checks against insmoding binaries or wrong arch,
848 weird elf version */
Cyrill Gorcunovd303f4a2008-05-04 17:50:02 +0100849 if (memcmp(hdr->e_ident, ELFMAG, SELFMAG) != 0
Ralf Baechle26009902006-04-05 09:45:45 +0100850 || (hdr->e_type != ET_REL && hdr->e_type != ET_EXEC)
851 || !elf_check_arch(hdr)
Ralf Baechlee01402b2005-07-14 15:57:16 +0000852 || hdr->e_shentsize != sizeof(*sechdrs)) {
853 printk(KERN_WARNING
Ralf Baechle26009902006-04-05 09:45:45 +0100854 "VPE loader: program wrong arch or weird elf version\n");
Ralf Baechlee01402b2005-07-14 15:57:16 +0000855
856 return -ENOEXEC;
857 }
858
Ralf Baechle26009902006-04-05 09:45:45 +0100859 if (hdr->e_type == ET_REL)
860 relocate = 1;
861
Ralf Baechlee01402b2005-07-14 15:57:16 +0000862 if (len < hdr->e_shoff + hdr->e_shnum * sizeof(Elf_Shdr)) {
Ralf Baechle26009902006-04-05 09:45:45 +0100863 printk(KERN_ERR "VPE loader: program length %u truncated\n",
864 len);
865
Ralf Baechlee01402b2005-07-14 15:57:16 +0000866 return -ENOEXEC;
867 }
868
869 /* Convenience variables */
870 sechdrs = (void *)hdr + hdr->e_shoff;
871 secstrings = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;
872 sechdrs[0].sh_addr = 0;
873
874 /* And these should exist, but gcc whinges if we don't init them */
875 symindex = strindex = 0;
876
Ralf Baechle26009902006-04-05 09:45:45 +0100877 if (relocate) {
878 for (i = 1; i < hdr->e_shnum; i++) {
879 if (sechdrs[i].sh_type != SHT_NOBITS
880 && len < sechdrs[i].sh_offset + sechdrs[i].sh_size) {
881 printk(KERN_ERR "VPE program length %u truncated\n",
882 len);
883 return -ENOEXEC;
884 }
Ralf Baechlee01402b2005-07-14 15:57:16 +0000885
Ralf Baechle26009902006-04-05 09:45:45 +0100886 /* Mark all sections sh_addr with their address in the
887 temporary image. */
888 sechdrs[i].sh_addr = (size_t) hdr + sechdrs[i].sh_offset;
889
890 /* Internal symbols and strings. */
891 if (sechdrs[i].sh_type == SHT_SYMTAB) {
892 symindex = i;
893 strindex = sechdrs[i].sh_link;
894 strtab = (char *)hdr + sechdrs[strindex].sh_offset;
895 }
Ralf Baechlee01402b2005-07-14 15:57:16 +0000896 }
Ralf Baechle26009902006-04-05 09:45:45 +0100897 layout_sections(&mod, hdr, sechdrs, secstrings);
Ralf Baechlee01402b2005-07-14 15:57:16 +0000898 }
899
Ralf Baechlee01402b2005-07-14 15:57:16 +0000900 v->load_addr = alloc_progmem(mod.core_size);
Ralf Baechle5408c492008-03-13 15:16:53 +0000901 if (!v->load_addr)
902 return -ENOMEM;
Ralf Baechlee01402b2005-07-14 15:57:16 +0000903
Ralf Baechle5408c492008-03-13 15:16:53 +0000904 pr_info("VPE loader: loading to %p\n", v->load_addr);
Ralf Baechlee01402b2005-07-14 15:57:16 +0000905
Ralf Baechle26009902006-04-05 09:45:45 +0100906 if (relocate) {
907 for (i = 0; i < hdr->e_shnum; i++) {
908 void *dest;
Ralf Baechlee01402b2005-07-14 15:57:16 +0000909
Ralf Baechle26009902006-04-05 09:45:45 +0100910 if (!(sechdrs[i].sh_flags & SHF_ALLOC))
911 continue;
Ralf Baechlee01402b2005-07-14 15:57:16 +0000912
Ralf Baechle26009902006-04-05 09:45:45 +0100913 dest = v->load_addr + sechdrs[i].sh_entsize;
Ralf Baechlee01402b2005-07-14 15:57:16 +0000914
Ralf Baechle26009902006-04-05 09:45:45 +0100915 if (sechdrs[i].sh_type != SHT_NOBITS)
916 memcpy(dest, (void *)sechdrs[i].sh_addr,
917 sechdrs[i].sh_size);
918 /* Update sh_addr to point to copy in image. */
919 sechdrs[i].sh_addr = (unsigned long)dest;
Ralf Baechlee01402b2005-07-14 15:57:16 +0000920
Ralf Baechle26009902006-04-05 09:45:45 +0100921 printk(KERN_DEBUG " section sh_name %s sh_addr 0x%x\n",
922 secstrings + sechdrs[i].sh_name, sechdrs[i].sh_addr);
923 }
Ralf Baechlee01402b2005-07-14 15:57:16 +0000924
Ralf Baechle26009902006-04-05 09:45:45 +0100925 /* Fix up syms, so that st_value is a pointer to location. */
926 simplify_symbols(sechdrs, symindex, strtab, secstrings,
927 hdr->e_shnum, &mod);
Ralf Baechlee01402b2005-07-14 15:57:16 +0000928
Ralf Baechle26009902006-04-05 09:45:45 +0100929 /* Now do relocations. */
930 for (i = 1; i < hdr->e_shnum; i++) {
931 const char *strtab = (char *)sechdrs[strindex].sh_addr;
932 unsigned int info = sechdrs[i].sh_info;
Ralf Baechlee01402b2005-07-14 15:57:16 +0000933
Ralf Baechle26009902006-04-05 09:45:45 +0100934 /* Not a valid relocation section? */
935 if (info >= hdr->e_shnum)
936 continue;
Ralf Baechlee01402b2005-07-14 15:57:16 +0000937
Ralf Baechle26009902006-04-05 09:45:45 +0100938 /* Don't bother with non-allocated sections */
939 if (!(sechdrs[info].sh_flags & SHF_ALLOC))
940 continue;
941
942 if (sechdrs[i].sh_type == SHT_REL)
943 err = apply_relocations(sechdrs, strtab, symindex, i,
944 &mod);
945 else if (sechdrs[i].sh_type == SHT_RELA)
946 err = apply_relocate_add(sechdrs, strtab, symindex, i,
947 &mod);
948 if (err < 0)
949 return err;
950
951 }
952 } else {
Ralf Baechlebdf5d422007-10-10 13:33:03 +0100953 struct elf_phdr *phdr = (struct elf_phdr *) ((char *)hdr + hdr->e_phoff);
Ralf Baechle26009902006-04-05 09:45:45 +0100954
Ralf Baechlebdf5d422007-10-10 13:33:03 +0100955 for (i = 0; i < hdr->e_phnum; i++) {
Kevin D. Kissellb6183362008-04-16 15:32:22 +0200956 if (phdr->p_type == PT_LOAD) {
957 memcpy((void *)phdr->p_paddr,
958 (char *)hdr + phdr->p_offset,
959 phdr->p_filesz);
960 memset((void *)phdr->p_paddr + phdr->p_filesz,
961 0, phdr->p_memsz - phdr->p_filesz);
962 }
963 phdr++;
Ralf Baechlebdf5d422007-10-10 13:33:03 +0100964 }
965
966 for (i = 0; i < hdr->e_shnum; i++) {
Ralf Baechle26009902006-04-05 09:45:45 +0100967 /* Internal symbols and strings. */
968 if (sechdrs[i].sh_type == SHT_SYMTAB) {
969 symindex = i;
970 strindex = sechdrs[i].sh_link;
971 strtab = (char *)hdr + sechdrs[strindex].sh_offset;
972
973 /* mark the symtab's address for when we try to find the
974 magic symbols */
975 sechdrs[i].sh_addr = (size_t) hdr + sechdrs[i].sh_offset;
976 }
Ralf Baechlee01402b2005-07-14 15:57:16 +0000977 }
978 }
979
980 /* make sure it's physically written out */
981 flush_icache_range((unsigned long)v->load_addr,
982 (unsigned long)v->load_addr + v->len);
983
984 if ((find_vpe_symbols(v, sechdrs, symindex, strtab, &mod)) < 0) {
Ralf Baechle26009902006-04-05 09:45:45 +0100985 if (v->__start == 0) {
986 printk(KERN_WARNING "VPE loader: program does not contain "
987 "a __start symbol\n");
988 return -ENOEXEC;
989 }
Ralf Baechlee01402b2005-07-14 15:57:16 +0000990
Ralf Baechle26009902006-04-05 09:45:45 +0100991 if (v->shared_ptr == NULL)
992 printk(KERN_WARNING "VPE loader: "
993 "program does not contain vpe_shared symbol.\n"
994 " Unable to use AMVP (AP/SP) facilities.\n");
Ralf Baechlee01402b2005-07-14 15:57:16 +0000995 }
996
997 printk(" elf loaded\n");
Ralf Baechle26009902006-04-05 09:45:45 +0100998 return 0;
Ralf Baechlee01402b2005-07-14 15:57:16 +0000999}
1000
Ralf Baechle26009902006-04-05 09:45:45 +01001001static void cleanup_tc(struct tc *tc)
1002{
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001003 unsigned long flags;
1004 unsigned int mtflags, vpflags;
Ralf Baechle26009902006-04-05 09:45:45 +01001005 int tmp;
1006
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001007 local_irq_save(flags);
1008 mtflags = dmt();
1009 vpflags = dvpe();
Ralf Baechle26009902006-04-05 09:45:45 +01001010 /* Put MVPE's into 'configuration state' */
1011 set_c0_mvpcontrol(MVPCONTROL_VPC);
1012
1013 settc(tc->index);
1014 tmp = read_tc_c0_tcstatus();
1015
1016 /* mark not allocated and not dynamically allocatable */
1017 tmp &= ~(TCSTATUS_A | TCSTATUS_DA);
1018 tmp |= TCSTATUS_IXMT; /* interrupt exempt */
1019 write_tc_c0_tcstatus(tmp);
1020
1021 write_tc_c0_tchalt(TCHALT_H);
Nigel Stephens7c3a6222007-11-08 13:25:51 +00001022 mips_ihb();
Ralf Baechle26009902006-04-05 09:45:45 +01001023
1024 /* bind it to anything other than VPE1 */
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001025// write_tc_c0_tcbind(read_tc_c0_tcbind() & ~TCBIND_CURVPE); // | TCBIND_CURVPE
Ralf Baechle26009902006-04-05 09:45:45 +01001026
1027 clear_c0_mvpcontrol(MVPCONTROL_VPC);
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001028 evpe(vpflags);
1029 emt(mtflags);
1030 local_irq_restore(flags);
Ralf Baechle26009902006-04-05 09:45:45 +01001031}
1032
1033static int getcwd(char *buff, int size)
1034{
1035 mm_segment_t old_fs;
1036 int ret;
1037
1038 old_fs = get_fs();
1039 set_fs(KERNEL_DS);
1040
Ralf Baechle21a151d2007-10-11 23:46:15 +01001041 ret = sys_getcwd(buff, size);
Ralf Baechle26009902006-04-05 09:45:45 +01001042
1043 set_fs(old_fs);
1044
1045 return ret;
1046}
1047
1048/* checks VPE is unused and gets ready to load program */
Ralf Baechlee01402b2005-07-14 15:57:16 +00001049static int vpe_open(struct inode *inode, struct file *filp)
1050{
Ralf Baechlec4c40182007-02-23 13:40:45 +00001051 enum vpe_state state;
Ralf Baechle26009902006-04-05 09:45:45 +01001052 struct vpe_notifications *not;
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001053 struct vpe *v;
Jonathan Corbet7558da92008-05-15 09:10:50 -06001054 int ret, err = 0;
Ralf Baechlee01402b2005-07-14 15:57:16 +00001055
Jonathan Corbet7558da92008-05-15 09:10:50 -06001056 lock_kernel();
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001057 if (minor != iminor(inode)) {
1058 /* assume only 1 device at the moment. */
Ralf Baechle26009902006-04-05 09:45:45 +01001059 printk(KERN_WARNING "VPE loader: only vpe1 is supported\n");
Jonathan Corbet7558da92008-05-15 09:10:50 -06001060 err = -ENODEV;
1061 goto out;
Ralf Baechlee01402b2005-07-14 15:57:16 +00001062 }
1063
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001064 if ((v = get_vpe(tclimit)) == NULL) {
Ralf Baechle26009902006-04-05 09:45:45 +01001065 printk(KERN_WARNING "VPE loader: unable to get vpe\n");
Jonathan Corbet7558da92008-05-15 09:10:50 -06001066 err = -ENODEV;
1067 goto out;
Ralf Baechlee01402b2005-07-14 15:57:16 +00001068 }
1069
Ralf Baechlec4c40182007-02-23 13:40:45 +00001070 state = xchg(&v->state, VPE_STATE_INUSE);
1071 if (state != VPE_STATE_UNUSED) {
Ralf Baechle26009902006-04-05 09:45:45 +01001072 printk(KERN_DEBUG "VPE loader: tc in use dumping regs\n");
1073
Ralf Baechle26009902006-04-05 09:45:45 +01001074 list_for_each_entry(not, &v->notify, list) {
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001075 not->stop(tclimit);
Ralf Baechle26009902006-04-05 09:45:45 +01001076 }
Ralf Baechlee01402b2005-07-14 15:57:16 +00001077
1078 release_progmem(v->load_addr);
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001079 cleanup_tc(get_tc(tclimit));
Ralf Baechlee01402b2005-07-14 15:57:16 +00001080 }
1081
Ralf Baechlee01402b2005-07-14 15:57:16 +00001082 /* this of-course trashes what was there before... */
1083 v->pbuffer = vmalloc(P_SIZE);
1084 v->plen = P_SIZE;
1085 v->load_addr = NULL;
1086 v->len = 0;
1087
David Howellsd76b0d92008-11-14 10:39:25 +11001088 v->uid = filp->f_cred->fsuid;
1089 v->gid = filp->f_cred->fsgid;
Ralf Baechle26009902006-04-05 09:45:45 +01001090
1091#ifdef CONFIG_MIPS_APSP_KSPD
1092 /* get kspd to tell us when a syscall_exit happens */
1093 if (!kspd_events_reqd) {
1094 kspd_notify(&kspd_events);
1095 kspd_events_reqd++;
1096 }
1097#endif
1098
1099 v->cwd[0] = 0;
1100 ret = getcwd(v->cwd, VPE_PATH_MAX);
1101 if (ret < 0)
1102 printk(KERN_WARNING "VPE loader: open, getcwd returned %d\n", ret);
1103
1104 v->shared_ptr = NULL;
1105 v->__start = 0;
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001106
Jonathan Corbet7558da92008-05-15 09:10:50 -06001107out:
1108 unlock_kernel();
Ralf Baechlee01402b2005-07-14 15:57:16 +00001109 return 0;
1110}
1111
1112static int vpe_release(struct inode *inode, struct file *filp)
1113{
Ralf Baechle307bd282005-10-31 23:34:52 +00001114 struct vpe *v;
Ralf Baechlee01402b2005-07-14 15:57:16 +00001115 Elf_Ehdr *hdr;
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001116 int ret = 0;
Ralf Baechlee01402b2005-07-14 15:57:16 +00001117
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001118 v = get_vpe(tclimit);
1119 if (v == NULL)
Ralf Baechlee01402b2005-07-14 15:57:16 +00001120 return -ENODEV;
1121
Ralf Baechlee01402b2005-07-14 15:57:16 +00001122 hdr = (Elf_Ehdr *) v->pbuffer;
Cyrill Gorcunovd303f4a2008-05-04 17:50:02 +01001123 if (memcmp(hdr->e_ident, ELFMAG, SELFMAG) == 0) {
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001124 if (vpe_elfload(v) >= 0) {
Ralf Baechlee01402b2005-07-14 15:57:16 +00001125 vpe_run(v);
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001126 } else {
Ralf Baechle26009902006-04-05 09:45:45 +01001127 printk(KERN_WARNING "VPE loader: ELF load failed.\n");
Ralf Baechlee01402b2005-07-14 15:57:16 +00001128 ret = -ENOEXEC;
1129 }
1130 } else {
Ralf Baechle26009902006-04-05 09:45:45 +01001131 printk(KERN_WARNING "VPE loader: only elf files are supported\n");
Ralf Baechlee01402b2005-07-14 15:57:16 +00001132 ret = -ENOEXEC;
1133 }
1134
Ralf Baechle26009902006-04-05 09:45:45 +01001135 /* It's good to be able to run the SP and if it chokes have a look at
1136 the /dev/rt?. But if we reset the pointer to the shared struct we
Nick Andrew8ebcfc82008-12-05 11:36:54 +11001137 lose what has happened. So perhaps if garbage is sent to the vpe
Ralf Baechle26009902006-04-05 09:45:45 +01001138 device, use it as a trigger for the reset. Hopefully a nice
1139 executable will be along shortly. */
1140 if (ret < 0)
1141 v->shared_ptr = NULL;
1142
Ralf Baechlee01402b2005-07-14 15:57:16 +00001143 // cleanup any temp buffers
1144 if (v->pbuffer)
1145 vfree(v->pbuffer);
1146 v->plen = 0;
1147 return ret;
1148}
1149
1150static ssize_t vpe_write(struct file *file, const char __user * buffer,
1151 size_t count, loff_t * ppos)
1152{
Ralf Baechlee01402b2005-07-14 15:57:16 +00001153 size_t ret = count;
Ralf Baechle307bd282005-10-31 23:34:52 +00001154 struct vpe *v;
Ralf Baechlee01402b2005-07-14 15:57:16 +00001155
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001156 if (iminor(file->f_path.dentry->d_inode) != minor)
1157 return -ENODEV;
1158
1159 v = get_vpe(tclimit);
1160 if (v == NULL)
Ralf Baechlee01402b2005-07-14 15:57:16 +00001161 return -ENODEV;
1162
1163 if (v->pbuffer == NULL) {
Ralf Baechle26009902006-04-05 09:45:45 +01001164 printk(KERN_ERR "VPE loader: no buffer for program\n");
Ralf Baechlee01402b2005-07-14 15:57:16 +00001165 return -ENOMEM;
1166 }
1167
1168 if ((count + v->len) > v->plen) {
1169 printk(KERN_WARNING
Ralf Baechle26009902006-04-05 09:45:45 +01001170 "VPE loader: elf size too big. Perhaps strip uneeded symbols\n");
Ralf Baechlee01402b2005-07-14 15:57:16 +00001171 return -ENOMEM;
1172 }
1173
1174 count -= copy_from_user(v->pbuffer + v->len, buffer, count);
Ralf Baechle26009902006-04-05 09:45:45 +01001175 if (!count)
Ralf Baechlee01402b2005-07-14 15:57:16 +00001176 return -EFAULT;
Ralf Baechlee01402b2005-07-14 15:57:16 +00001177
1178 v->len += count;
1179 return ret;
1180}
1181
Arjan van de Ven5dfe4c92007-02-12 00:55:31 -08001182static const struct file_operations vpe_fops = {
Ralf Baechlee01402b2005-07-14 15:57:16 +00001183 .owner = THIS_MODULE,
1184 .open = vpe_open,
1185 .release = vpe_release,
1186 .write = vpe_write
1187};
1188
1189/* module wrapper entry points */
1190/* give me a vpe */
1191vpe_handle vpe_alloc(void)
1192{
1193 int i;
1194 struct vpe *v;
1195
1196 /* find a vpe */
1197 for (i = 1; i < MAX_VPES; i++) {
1198 if ((v = get_vpe(i)) != NULL) {
1199 v->state = VPE_STATE_INUSE;
1200 return v;
1201 }
1202 }
1203 return NULL;
1204}
1205
1206EXPORT_SYMBOL(vpe_alloc);
1207
1208/* start running from here */
1209int vpe_start(vpe_handle vpe, unsigned long start)
1210{
1211 struct vpe *v = vpe;
1212
1213 v->__start = start;
1214 return vpe_run(v);
1215}
1216
1217EXPORT_SYMBOL(vpe_start);
1218
1219/* halt it for now */
1220int vpe_stop(vpe_handle vpe)
1221{
1222 struct vpe *v = vpe;
1223 struct tc *t;
1224 unsigned int evpe_flags;
1225
1226 evpe_flags = dvpe();
1227
1228 if ((t = list_entry(v->tc.next, struct tc, tc)) != NULL) {
1229
1230 settc(t->index);
1231 write_vpe_c0_vpeconf0(read_vpe_c0_vpeconf0() & ~VPECONF0_VPA);
1232 }
1233
1234 evpe(evpe_flags);
1235
1236 return 0;
1237}
1238
1239EXPORT_SYMBOL(vpe_stop);
1240
1241/* I've done with it thank you */
1242int vpe_free(vpe_handle vpe)
1243{
1244 struct vpe *v = vpe;
1245 struct tc *t;
1246 unsigned int evpe_flags;
1247
1248 if ((t = list_entry(v->tc.next, struct tc, tc)) == NULL) {
1249 return -ENOEXEC;
1250 }
1251
1252 evpe_flags = dvpe();
1253
1254 /* Put MVPE's into 'configuration state' */
Ralf Baechle340ee4b2005-08-17 17:44:08 +00001255 set_c0_mvpcontrol(MVPCONTROL_VPC);
Ralf Baechlee01402b2005-07-14 15:57:16 +00001256
1257 settc(t->index);
1258 write_vpe_c0_vpeconf0(read_vpe_c0_vpeconf0() & ~VPECONF0_VPA);
1259
Nigel Stephens7c3a6222007-11-08 13:25:51 +00001260 /* halt the TC */
Ralf Baechlee01402b2005-07-14 15:57:16 +00001261 write_tc_c0_tchalt(TCHALT_H);
Nigel Stephens7c3a6222007-11-08 13:25:51 +00001262 mips_ihb();
1263
1264 /* mark the TC unallocated */
1265 write_tc_c0_tcstatus(read_tc_c0_tcstatus() & ~TCSTATUS_A);
Ralf Baechlee01402b2005-07-14 15:57:16 +00001266
1267 v->state = VPE_STATE_UNUSED;
1268
Ralf Baechle340ee4b2005-08-17 17:44:08 +00001269 clear_c0_mvpcontrol(MVPCONTROL_VPC);
Ralf Baechlee01402b2005-07-14 15:57:16 +00001270 evpe(evpe_flags);
1271
1272 return 0;
1273}
1274
1275EXPORT_SYMBOL(vpe_free);
1276
1277void *vpe_get_shared(int index)
1278{
1279 struct vpe *v;
1280
Ralf Baechle26009902006-04-05 09:45:45 +01001281 if ((v = get_vpe(index)) == NULL)
Ralf Baechlee01402b2005-07-14 15:57:16 +00001282 return NULL;
Ralf Baechlee01402b2005-07-14 15:57:16 +00001283
1284 return v->shared_ptr;
1285}
1286
1287EXPORT_SYMBOL(vpe_get_shared);
1288
Ralf Baechle26009902006-04-05 09:45:45 +01001289int vpe_getuid(int index)
1290{
1291 struct vpe *v;
1292
1293 if ((v = get_vpe(index)) == NULL)
1294 return -1;
1295
1296 return v->uid;
1297}
1298
1299EXPORT_SYMBOL(vpe_getuid);
1300
1301int vpe_getgid(int index)
1302{
1303 struct vpe *v;
1304
1305 if ((v = get_vpe(index)) == NULL)
1306 return -1;
1307
1308 return v->gid;
1309}
1310
1311EXPORT_SYMBOL(vpe_getgid);
1312
1313int vpe_notify(int index, struct vpe_notifications *notify)
1314{
1315 struct vpe *v;
1316
1317 if ((v = get_vpe(index)) == NULL)
1318 return -1;
1319
1320 list_add(&notify->list, &v->notify);
1321 return 0;
1322}
1323
1324EXPORT_SYMBOL(vpe_notify);
1325
1326char *vpe_getcwd(int index)
1327{
1328 struct vpe *v;
1329
1330 if ((v = get_vpe(index)) == NULL)
1331 return NULL;
1332
1333 return v->cwd;
1334}
1335
1336EXPORT_SYMBOL(vpe_getcwd);
1337
1338#ifdef CONFIG_MIPS_APSP_KSPD
1339static void kspd_sp_exit( int sp_id)
1340{
1341 cleanup_tc(get_tc(sp_id));
1342}
1343#endif
1344
Kay Sievers736fad12007-10-15 13:42:35 +02001345static ssize_t store_kill(struct device *dev, struct device_attribute *attr,
1346 const char *buf, size_t len)
Ralf Baechle0f5d0df2007-07-27 19:37:51 +01001347{
1348 struct vpe *vpe = get_vpe(tclimit);
1349 struct vpe_notifications *not;
1350
1351 list_for_each_entry(not, &vpe->notify, list) {
1352 not->stop(tclimit);
1353 }
1354
1355 release_progmem(vpe->load_addr);
1356 cleanup_tc(get_tc(tclimit));
1357 vpe_stop(vpe);
1358 vpe_free(vpe);
1359
1360 return len;
1361}
1362
Kay Sievers736fad12007-10-15 13:42:35 +02001363static ssize_t show_ntcs(struct device *cd, struct device_attribute *attr,
1364 char *buf)
Ralf Baechle41790e02007-07-27 19:33:18 +01001365{
1366 struct vpe *vpe = get_vpe(tclimit);
1367
1368 return sprintf(buf, "%d\n", vpe->ntcs);
1369}
1370
Kay Sievers736fad12007-10-15 13:42:35 +02001371static ssize_t store_ntcs(struct device *dev, struct device_attribute *attr,
1372 const char *buf, size_t len)
Ralf Baechle41790e02007-07-27 19:33:18 +01001373{
1374 struct vpe *vpe = get_vpe(tclimit);
1375 unsigned long new;
1376 char *endp;
1377
1378 new = simple_strtoul(buf, &endp, 0);
1379 if (endp == buf)
1380 goto out_einval;
1381
1382 if (new == 0 || new > (hw_tcs - tclimit))
1383 goto out_einval;
1384
1385 vpe->ntcs = new;
1386
1387 return len;
1388
1389out_einval:
1390 return -EINVAL;;
1391}
1392
Kay Sievers736fad12007-10-15 13:42:35 +02001393static struct device_attribute vpe_class_attributes[] = {
Ralf Baechle0f5d0df2007-07-27 19:37:51 +01001394 __ATTR(kill, S_IWUSR, NULL, store_kill),
Ralf Baechle41790e02007-07-27 19:33:18 +01001395 __ATTR(ntcs, S_IRUGO | S_IWUSR, show_ntcs, store_ntcs),
1396 {}
1397};
1398
Kay Sievers736fad12007-10-15 13:42:35 +02001399static void vpe_device_release(struct device *cd)
Ralf Baechle41790e02007-07-27 19:33:18 +01001400{
1401 kfree(cd);
1402}
1403
1404struct class vpe_class = {
1405 .name = "vpe",
1406 .owner = THIS_MODULE,
Kay Sievers736fad12007-10-15 13:42:35 +02001407 .dev_release = vpe_device_release,
1408 .dev_attrs = vpe_class_attributes,
Ralf Baechle41790e02007-07-27 19:33:18 +01001409};
1410
Kay Sievers736fad12007-10-15 13:42:35 +02001411struct device vpe_device;
Ralf Baechle27a3bba2007-02-07 13:48:59 +00001412
Ralf Baechlee01402b2005-07-14 15:57:16 +00001413static int __init vpe_module_init(void)
1414{
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001415 unsigned int mtflags, vpflags;
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001416 unsigned long flags, val;
Ralf Baechlee01402b2005-07-14 15:57:16 +00001417 struct vpe *v = NULL;
1418 struct tc *t;
Ralf Baechle41790e02007-07-27 19:33:18 +01001419 int tc, err;
Ralf Baechlee01402b2005-07-14 15:57:16 +00001420
1421 if (!cpu_has_mipsmt) {
1422 printk("VPE loader: not a MIPS MT capable processor\n");
1423 return -ENODEV;
1424 }
1425
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001426 if (vpelimit == 0) {
1427 printk(KERN_WARNING "No VPEs reserved for AP/SP, not "
1428 "initializing VPE loader.\nPass maxvpes=<n> argument as "
1429 "kernel argument\n");
1430
1431 return -ENODEV;
1432 }
1433
1434 if (tclimit == 0) {
1435 printk(KERN_WARNING "No TCs reserved for AP/SP, not "
1436 "initializing VPE loader.\nPass maxtcs=<n> argument as "
1437 "kernel argument\n");
1438
1439 return -ENODEV;
1440 }
1441
Alexey Dobriyan682e8522006-01-10 00:09:16 +03001442 major = register_chrdev(0, module_name, &vpe_fops);
1443 if (major < 0) {
Ralf Baechlee01402b2005-07-14 15:57:16 +00001444 printk("VPE loader: unable to register character device\n");
Ralf Baechle307bd282005-10-31 23:34:52 +00001445 return major;
Ralf Baechlee01402b2005-07-14 15:57:16 +00001446 }
1447
Ralf Baechle41790e02007-07-27 19:33:18 +01001448 err = class_register(&vpe_class);
1449 if (err) {
1450 printk(KERN_ERR "vpe_class registration failed\n");
Ralf Baechle27a3bba2007-02-07 13:48:59 +00001451 goto out_chrdev;
1452 }
Ralf Baechle41790e02007-07-27 19:33:18 +01001453
Kay Sievers736fad12007-10-15 13:42:35 +02001454 device_initialize(&vpe_device);
Ralf Baechle41790e02007-07-27 19:33:18 +01001455 vpe_device.class = &vpe_class,
1456 vpe_device.parent = NULL,
Kay Sievers1bb5beb2009-01-06 10:44:38 -08001457 dev_set_name(&vpe_device, "vpe1");
Ralf Baechle41790e02007-07-27 19:33:18 +01001458 vpe_device.devt = MKDEV(major, minor);
Kay Sievers736fad12007-10-15 13:42:35 +02001459 err = device_add(&vpe_device);
Ralf Baechle41790e02007-07-27 19:33:18 +01001460 if (err) {
1461 printk(KERN_ERR "Adding vpe_device failed\n");
1462 goto out_class;
1463 }
Ralf Baechle27a3bba2007-02-07 13:48:59 +00001464
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001465 local_irq_save(flags);
1466 mtflags = dmt();
1467 vpflags = dvpe();
Ralf Baechlee01402b2005-07-14 15:57:16 +00001468
1469 /* Put MVPE's into 'configuration state' */
Ralf Baechle340ee4b2005-08-17 17:44:08 +00001470 set_c0_mvpcontrol(MVPCONTROL_VPC);
Ralf Baechlee01402b2005-07-14 15:57:16 +00001471
1472 /* dump_mtregs(); */
1473
Ralf Baechlee01402b2005-07-14 15:57:16 +00001474 val = read_c0_mvpconf0();
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001475 hw_tcs = (val & MVPCONF0_PTC) + 1;
1476 hw_vpes = ((val & MVPCONF0_PVPE) >> MVPCONF0_PVPE_SHIFT) + 1;
1477
1478 for (tc = tclimit; tc < hw_tcs; tc++) {
1479 /*
1480 * Must re-enable multithreading temporarily or in case we
1481 * reschedule send IPIs or similar we might hang.
1482 */
1483 clear_c0_mvpcontrol(MVPCONTROL_VPC);
1484 evpe(vpflags);
1485 emt(mtflags);
1486 local_irq_restore(flags);
1487 t = alloc_tc(tc);
1488 if (!t) {
1489 err = -ENOMEM;
1490 goto out;
1491 }
1492
1493 local_irq_save(flags);
1494 mtflags = dmt();
1495 vpflags = dvpe();
1496 set_c0_mvpcontrol(MVPCONTROL_VPC);
Ralf Baechlee01402b2005-07-14 15:57:16 +00001497
1498 /* VPE's */
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001499 if (tc < hw_tcs) {
1500 settc(tc);
Ralf Baechlee01402b2005-07-14 15:57:16 +00001501
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001502 if ((v = alloc_vpe(tc)) == NULL) {
Ralf Baechlee01402b2005-07-14 15:57:16 +00001503 printk(KERN_WARNING "VPE: unable to allocate VPE\n");
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001504
1505 goto out_reenable;
Ralf Baechlee01402b2005-07-14 15:57:16 +00001506 }
1507
Ralf Baechle41790e02007-07-27 19:33:18 +01001508 v->ntcs = hw_tcs - tclimit;
1509
Ralf Baechle26009902006-04-05 09:45:45 +01001510 /* add the tc to the list of this vpe's tc's. */
1511 list_add(&t->tc, &v->tc);
Ralf Baechlee01402b2005-07-14 15:57:16 +00001512
1513 /* deactivate all but vpe0 */
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001514 if (tc >= tclimit) {
Ralf Baechlee01402b2005-07-14 15:57:16 +00001515 unsigned long tmp = read_vpe_c0_vpeconf0();
1516
1517 tmp &= ~VPECONF0_VPA;
1518
1519 /* master VPE */
1520 tmp |= VPECONF0_MVP;
1521 write_vpe_c0_vpeconf0(tmp);
1522 }
1523
1524 /* disable multi-threading with TC's */
1525 write_vpe_c0_vpecontrol(read_vpe_c0_vpecontrol() & ~VPECONTROL_TE);
1526
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001527 if (tc >= vpelimit) {
Ralf Baechle26009902006-04-05 09:45:45 +01001528 /*
1529 * Set config to be the same as vpe0,
1530 * particularly kseg0 coherency alg
1531 */
Ralf Baechlee01402b2005-07-14 15:57:16 +00001532 write_vpe_c0_config(read_c0_config());
1533 }
Ralf Baechlee01402b2005-07-14 15:57:16 +00001534 }
1535
1536 /* TC's */
1537 t->pvpe = v; /* set the parent vpe */
1538
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001539 if (tc >= tclimit) {
Ralf Baechlee01402b2005-07-14 15:57:16 +00001540 unsigned long tmp;
1541
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001542 settc(tc);
Ralf Baechlee01402b2005-07-14 15:57:16 +00001543
Ralf Baechle26009902006-04-05 09:45:45 +01001544 /* Any TC that is bound to VPE0 gets left as is - in case
1545 we are running SMTC on VPE0. A TC that is bound to any
1546 other VPE gets bound to VPE0, ideally I'd like to make
1547 it homeless but it doesn't appear to let me bind a TC
1548 to a non-existent VPE. Which is perfectly reasonable.
1549
1550 The (un)bound state is visible to an EJTAG probe so may
1551 notify GDB...
1552 */
1553
1554 if (((tmp = read_tc_c0_tcbind()) & TCBIND_CURVPE)) {
1555 /* tc is bound >vpe0 */
1556 write_tc_c0_tcbind(tmp & ~TCBIND_CURVPE);
1557
1558 t->pvpe = get_vpe(0); /* set the parent vpe */
1559 }
Ralf Baechlee01402b2005-07-14 15:57:16 +00001560
Nigel Stephens7c3a6222007-11-08 13:25:51 +00001561 /* halt the TC */
1562 write_tc_c0_tchalt(TCHALT_H);
1563 mips_ihb();
1564
Ralf Baechlee01402b2005-07-14 15:57:16 +00001565 tmp = read_tc_c0_tcstatus();
1566
Ralf Baechle26009902006-04-05 09:45:45 +01001567 /* mark not activated and not dynamically allocatable */
Ralf Baechlee01402b2005-07-14 15:57:16 +00001568 tmp &= ~(TCSTATUS_A | TCSTATUS_DA);
1569 tmp |= TCSTATUS_IXMT; /* interrupt exempt */
1570 write_tc_c0_tcstatus(tmp);
Ralf Baechlee01402b2005-07-14 15:57:16 +00001571 }
1572 }
1573
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001574out_reenable:
Ralf Baechlee01402b2005-07-14 15:57:16 +00001575 /* release config state */
Ralf Baechle340ee4b2005-08-17 17:44:08 +00001576 clear_c0_mvpcontrol(MVPCONTROL_VPC);
Ralf Baechlee01402b2005-07-14 15:57:16 +00001577
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001578 evpe(vpflags);
1579 emt(mtflags);
1580 local_irq_restore(flags);
1581
Ralf Baechle26009902006-04-05 09:45:45 +01001582#ifdef CONFIG_MIPS_APSP_KSPD
1583 kspd_events.kspd_sp_exit = kspd_sp_exit;
1584#endif
Ralf Baechlee01402b2005-07-14 15:57:16 +00001585 return 0;
Ralf Baechle27a3bba2007-02-07 13:48:59 +00001586
Ralf Baechle41790e02007-07-27 19:33:18 +01001587out_class:
1588 class_unregister(&vpe_class);
Ralf Baechle27a3bba2007-02-07 13:48:59 +00001589out_chrdev:
1590 unregister_chrdev(major, module_name);
1591
Ralf Baechle07cc0c92007-07-27 19:31:10 +01001592out:
Ralf Baechle27a3bba2007-02-07 13:48:59 +00001593 return err;
Ralf Baechlee01402b2005-07-14 15:57:16 +00001594}
1595
1596static void __exit vpe_module_exit(void)
1597{
1598 struct vpe *v, *n;
1599
1600 list_for_each_entry_safe(v, n, &vpecontrol.vpe_list, list) {
1601 if (v->state != VPE_STATE_UNUSED) {
1602 release_vpe(v);
1603 }
1604 }
1605
Kay Sievers736fad12007-10-15 13:42:35 +02001606 device_del(&vpe_device);
Ralf Baechlee01402b2005-07-14 15:57:16 +00001607 unregister_chrdev(major, module_name);
1608}
1609
1610module_init(vpe_module_init);
1611module_exit(vpe_module_exit);
1612MODULE_DESCRIPTION("MIPS VPE Loader");
Ralf Baechle26009902006-04-05 09:45:45 +01001613MODULE_AUTHOR("Elizabeth Oldham, MIPS Technologies, Inc.");
Ralf Baechlee01402b2005-07-14 15:57:16 +00001614MODULE_LICENSE("GPL");