aboutsummaryrefslogtreecommitdiffstats
path: root/arch/mips
diff options
context:
space:
mode:
authorDeng-Cheng Zhu <dengcheng.zhu@imgtec.com>2013-10-30 16:52:06 -0400
committerRalf Baechle <ralf@linux-mips.org>2014-01-22 14:19:01 -0500
commit1a2a6d7e8816ed2b2679a0c4f7ba4019cd31dd62 (patch)
treec7ae6f594ac9ee8e2c791b48d2d18a0bec326b9a /arch/mips
parentc080faa502041c94f754e9878618a4632d6eede6 (diff)
MIPS: APRP: Split VPE loader into separate files.
Split the VPE functionality in preparation for adding support for CMP platforms. Common functions remain in the original file and a new file contains code specific to platforms that do not have a CMP present. Signed-off-by: Deng-Cheng Zhu <dengcheng.zhu@imgtec.com> Signed-off-by: Steven J. Hill <Steven.Hill@imgtec.com> Reviewed-by: Qais Yousef <Qais.Yousef@imgtec.com> Signed-off-by: John Crispin <blogic@openwrt.org> Patchwork: http://patchwork.linux-mips.org/patch/6094/
Diffstat (limited to 'arch/mips')
-rw-r--r--arch/mips/Kconfig5
-rw-r--r--arch/mips/include/asm/vpe.h117
-rw-r--r--arch/mips/kernel/Makefile1
-rw-r--r--arch/mips/kernel/vpe-mt.c523
-rw-r--r--arch/mips/kernel/vpe.c647
5 files changed, 660 insertions, 633 deletions
diff --git a/arch/mips/Kconfig b/arch/mips/Kconfig
index 5ee558b317ed..741fc31463c1 100644
--- a/arch/mips/Kconfig
+++ b/arch/mips/Kconfig
@@ -1907,6 +1907,11 @@ config MIPS_VPE_LOADER
1907 Includes a loader for loading an elf relocatable object 1907 Includes a loader for loading an elf relocatable object
1908 onto another VPE and running it. 1908 onto another VPE and running it.
1909 1909
1910config MIPS_VPE_LOADER_MT
1911 bool
1912 default "y"
1913 depends on MIPS_VPE_LOADER && !MIPS_CMP
1914
1910config MIPS_MT_SMTC_IM_BACKSTOP 1915config MIPS_MT_SMTC_IM_BACKSTOP
1911 bool "Use per-TC register bits as backstop for inhibited IM bits" 1916 bool "Use per-TC register bits as backstop for inhibited IM bits"
1912 depends on MIPS_MT_SMTC 1917 depends on MIPS_MT_SMTC
diff --git a/arch/mips/include/asm/vpe.h b/arch/mips/include/asm/vpe.h
index c6e1b961537d..becd5554cf5b 100644
--- a/arch/mips/include/asm/vpe.h
+++ b/arch/mips/include/asm/vpe.h
@@ -1,5 +1,6 @@
1/* 1/*
2 * Copyright (C) 2005 MIPS Technologies, Inc. All rights reserved. 2 * Copyright (C) 2005 MIPS Technologies, Inc. All rights reserved.
3 * Copyright (C) 2013 Imagination Technologies Ltd.
3 * 4 *
4 * This program is free software; you can distribute it and/or modify it 5 * 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 * under the terms of the GNU General Public License (Version 2) as
@@ -19,6 +20,88 @@
19#ifndef _ASM_VPE_H 20#ifndef _ASM_VPE_H
20#define _ASM_VPE_H 21#define _ASM_VPE_H
21 22
23#include <linux/init.h>
24#include <linux/list.h>
25#include <linux/smp.h>
26#include <linux/spinlock.h>
27
28#define VPE_MODULE_NAME "vpe"
29#define VPE_MODULE_MINOR 1
30
31/* grab the likely amount of memory we will need. */
32#ifdef CONFIG_MIPS_VPE_LOADER_TOM
33#define P_SIZE (2 * 1024 * 1024)
34#else
35/* add an overhead to the max kmalloc size for non-striped symbols/etc */
36#define P_SIZE (256 * 1024)
37#endif
38
39#define MAX_VPES 16
40#define VPE_PATH_MAX 256
41
42static inline int aprp_cpu_index(void)
43{
44#ifdef CONFIG_MIPS_CMP
45 return setup_max_cpus;
46#else
47 extern int tclimit;
48 return tclimit;
49#endif
50}
51
52enum vpe_state {
53 VPE_STATE_UNUSED = 0,
54 VPE_STATE_INUSE,
55 VPE_STATE_RUNNING
56};
57
58enum tc_state {
59 TC_STATE_UNUSED = 0,
60 TC_STATE_INUSE,
61 TC_STATE_RUNNING,
62 TC_STATE_DYNAMIC
63};
64
65struct vpe {
66 enum vpe_state state;
67
68 /* (device) minor associated with this vpe */
69 int minor;
70
71 /* elfloader stuff */
72 void *load_addr;
73 unsigned long len;
74 char *pbuffer;
75 unsigned long plen;
76 unsigned int uid, gid;
77 char cwd[VPE_PATH_MAX];
78
79 unsigned long __start;
80
81 /* tc's associated with this vpe */
82 struct list_head tc;
83
84 /* The list of vpe's */
85 struct list_head list;
86
87 /* shared symbol address */
88 void *shared_ptr;
89
90 /* the list of who wants to know when something major happens */
91 struct list_head notify;
92
93 unsigned int ntcs;
94};
95
96struct tc {
97 enum tc_state state;
98 int index;
99
100 struct vpe *pvpe; /* parent VPE */
101 struct list_head tc; /* The list of TC's with this VPE */
102 struct list_head list; /* The global list of tc's */
103};
104
22struct vpe_notifications { 105struct vpe_notifications {
23 void (*start)(int vpe); 106 void (*start)(int vpe);
24 void (*stop)(int vpe); 107 void (*stop)(int vpe);
@@ -26,12 +109,36 @@ struct vpe_notifications {
26 struct list_head list; 109 struct list_head list;
27}; 110};
28 111
112struct vpe_control {
113 spinlock_t vpe_list_lock;
114 struct list_head vpe_list; /* Virtual processing elements */
115 spinlock_t tc_list_lock;
116 struct list_head tc_list; /* Thread contexts */
117};
118
119extern unsigned long physical_memsize;
120extern struct vpe_control vpecontrol;
121extern const struct file_operations vpe_fops;
122
123int vpe_notify(int index, struct vpe_notifications *notify);
124
125void *vpe_get_shared(int index);
126int vpe_getuid(int index);
127int vpe_getgid(int index);
128char *vpe_getcwd(int index);
129
130struct vpe *get_vpe(int minor);
131struct tc *get_tc(int index);
132struct vpe *alloc_vpe(int minor);
133struct tc *alloc_tc(int index);
134void release_vpe(struct vpe *v);
29 135
30extern int vpe_notify(int index, struct vpe_notifications *notify); 136void *alloc_progmem(unsigned long len);
137void release_progmem(void *ptr);
31 138
32extern void *vpe_get_shared(int index); 139int __weak vpe_run(struct vpe *v);
33extern int vpe_getuid(int index); 140void cleanup_tc(struct tc *tc);
34extern int vpe_getgid(int index);
35extern char *vpe_getcwd(int index);
36 141
142int __init vpe_module_init(void);
143void __exit vpe_module_exit(void);
37#endif /* _ASM_VPE_H */ 144#endif /* _ASM_VPE_H */
diff --git a/arch/mips/kernel/Makefile b/arch/mips/kernel/Makefile
index b95eb7411d0c..de28da1a8757 100644
--- a/arch/mips/kernel/Makefile
+++ b/arch/mips/kernel/Makefile
@@ -56,6 +56,7 @@ obj-$(CONFIG_MIPS_CMP) += smp-cmp.o
56obj-$(CONFIG_CPU_MIPSR2) += spram.o 56obj-$(CONFIG_CPU_MIPSR2) += spram.o
57 57
58obj-$(CONFIG_MIPS_VPE_LOADER) += vpe.o 58obj-$(CONFIG_MIPS_VPE_LOADER) += vpe.o
59obj-$(CONFIG_MIPS_VPE_LOADER_MT) += vpe-mt.o
59obj-$(CONFIG_MIPS_VPE_APSP_API) += rtlx.o 60obj-$(CONFIG_MIPS_VPE_APSP_API) += rtlx.o
60 61
61obj-$(CONFIG_I8259) += i8259.o 62obj-$(CONFIG_I8259) += i8259.o
diff --git a/arch/mips/kernel/vpe-mt.c b/arch/mips/kernel/vpe-mt.c
new file mode 100644
index 000000000000..45abe9abb611
--- /dev/null
+++ b/arch/mips/kernel/vpe-mt.c
@@ -0,0 +1,523 @@
1/*
2 * This file is subject to the terms and conditions of the GNU General Public
3 * License. See the file "COPYING" in the main directory of this archive
4 * for more details.
5 *
6 * Copyright (C) 2004, 2005 MIPS Technologies, Inc. All rights reserved.
7 * Copyright (C) 2013 Imagination Technologies Ltd.
8 */
9#include <linux/kernel.h>
10#include <linux/device.h>
11#include <linux/fs.h>
12#include <linux/slab.h>
13#include <linux/export.h>
14
15#include <asm/mipsregs.h>
16#include <asm/mipsmtregs.h>
17#include <asm/mips_mt.h>
18#include <asm/vpe.h>
19
20static int major;
21
22/* The number of TCs and VPEs physically available on the core */
23static int hw_tcs, hw_vpes;
24
25/* We are prepared so configure and start the VPE... */
26int vpe_run(struct vpe *v)
27{
28 unsigned long flags, val, dmt_flag;
29 struct vpe_notifications *n;
30 unsigned int vpeflags;
31 struct tc *t;
32
33 /* check we are the Master VPE */
34 local_irq_save(flags);
35 val = read_c0_vpeconf0();
36 if (!(val & VPECONF0_MVP)) {
37 pr_warn("VPE loader: only Master VPE's are able to config MT\n");
38 local_irq_restore(flags);
39
40 return -1;
41 }
42
43 dmt_flag = dmt();
44 vpeflags = dvpe();
45
46 if (list_empty(&v->tc)) {
47 evpe(vpeflags);
48 emt(dmt_flag);
49 local_irq_restore(flags);
50
51 pr_warn("VPE loader: No TC's associated with VPE %d\n",
52 v->minor);
53
54 return -ENOEXEC;
55 }
56
57 t = list_first_entry(&v->tc, struct tc, tc);
58
59 /* Put MVPE's into 'configuration state' */
60 set_c0_mvpcontrol(MVPCONTROL_VPC);
61
62 settc(t->index);
63
64 /* should check it is halted, and not activated */
65 if ((read_tc_c0_tcstatus() & TCSTATUS_A) ||
66 !(read_tc_c0_tchalt() & TCHALT_H)) {
67 evpe(vpeflags);
68 emt(dmt_flag);
69 local_irq_restore(flags);
70
71 pr_warn("VPE loader: TC %d is already active!\n",
72 t->index);
73
74 return -ENOEXEC;
75 }
76
77 /*
78 * Write the address we want it to start running from in the TCPC
79 * register.
80 */
81 write_tc_c0_tcrestart((unsigned long)v->__start);
82 write_tc_c0_tccontext((unsigned long)0);
83
84 /*
85 * Mark the TC as activated, not interrupt exempt and not dynamically
86 * allocatable
87 */
88 val = read_tc_c0_tcstatus();
89 val = (val & ~(TCSTATUS_DA | TCSTATUS_IXMT)) | TCSTATUS_A;
90 write_tc_c0_tcstatus(val);
91
92 write_tc_c0_tchalt(read_tc_c0_tchalt() & ~TCHALT_H);
93
94 /*
95 * The sde-kit passes 'memsize' to __start in $a3, so set something
96 * here... Or set $a3 to zero and define DFLT_STACK_SIZE and
97 * DFLT_HEAP_SIZE when you compile your program
98 */
99 mttgpr(6, v->ntcs);
100 mttgpr(7, physical_memsize);
101
102 /* set up VPE1 */
103 /*
104 * bind the TC to VPE 1 as late as possible so we only have the final
105 * VPE registers to set up, and so an EJTAG probe can trigger on it
106 */
107 write_tc_c0_tcbind((read_tc_c0_tcbind() & ~TCBIND_CURVPE) | 1);
108
109 write_vpe_c0_vpeconf0(read_vpe_c0_vpeconf0() & ~(VPECONF0_VPA));
110
111 back_to_back_c0_hazard();
112
113 /* Set up the XTC bit in vpeconf0 to point at our tc */
114 write_vpe_c0_vpeconf0((read_vpe_c0_vpeconf0() & ~(VPECONF0_XTC))
115 | (t->index << VPECONF0_XTC_SHIFT));
116
117 back_to_back_c0_hazard();
118
119 /* enable this VPE */
120 write_vpe_c0_vpeconf0(read_vpe_c0_vpeconf0() | VPECONF0_VPA);
121
122 /* clear out any left overs from a previous program */
123 write_vpe_c0_status(0);
124 write_vpe_c0_cause(0);
125
126 /* take system out of configuration state */
127 clear_c0_mvpcontrol(MVPCONTROL_VPC);
128
129 /*
130 * SMTC/SMVP kernels manage VPE enable independently,
131 * but uniprocessor kernels need to turn it on, even
132 * if that wasn't the pre-dvpe() state.
133 */
134#ifdef CONFIG_SMP
135 evpe(vpeflags);
136#else
137 evpe(EVPE_ENABLE);
138#endif
139 emt(dmt_flag);
140 local_irq_restore(flags);
141
142 list_for_each_entry(n, &v->notify, list)
143 n->start(VPE_MODULE_MINOR);
144
145 return 0;
146}
147
148void cleanup_tc(struct tc *tc)
149{
150 unsigned long flags;
151 unsigned int mtflags, vpflags;
152 int tmp;
153
154 local_irq_save(flags);
155 mtflags = dmt();
156 vpflags = dvpe();
157 /* Put MVPE's into 'configuration state' */
158 set_c0_mvpcontrol(MVPCONTROL_VPC);
159
160 settc(tc->index);
161 tmp = read_tc_c0_tcstatus();
162
163 /* mark not allocated and not dynamically allocatable */
164 tmp &= ~(TCSTATUS_A | TCSTATUS_DA);
165 tmp |= TCSTATUS_IXMT; /* interrupt exempt */
166 write_tc_c0_tcstatus(tmp);
167
168 write_tc_c0_tchalt(TCHALT_H);
169 mips_ihb();
170
171 clear_c0_mvpcontrol(MVPCONTROL_VPC);
172 evpe(vpflags);
173 emt(mtflags);
174 local_irq_restore(flags);
175}
176
177/* module wrapper entry points */
178/* give me a vpe */
179void *vpe_alloc(void)
180{
181 int i;
182 struct vpe *v;
183
184 /* find a vpe */
185 for (i = 1; i < MAX_VPES; i++) {
186 v = get_vpe(i);
187 if (v != NULL) {
188 v->state = VPE_STATE_INUSE;
189 return v;
190 }
191 }
192 return NULL;
193}
194EXPORT_SYMBOL(vpe_alloc);
195
196/* start running from here */
197int vpe_start(void *vpe, unsigned long start)
198{
199 struct vpe *v = vpe;
200
201 v->__start = start;
202 return vpe_run(v);
203}
204EXPORT_SYMBOL(vpe_start);
205
206/* halt it for now */
207int vpe_stop(void *vpe)
208{
209 struct vpe *v = vpe;
210 struct tc *t;
211 unsigned int evpe_flags;
212
213 evpe_flags = dvpe();
214
215 t = list_entry(v->tc.next, struct tc, tc);
216 if (t != NULL) {
217 settc(t->index);
218 write_vpe_c0_vpeconf0(read_vpe_c0_vpeconf0() & ~VPECONF0_VPA);
219 }
220
221 evpe(evpe_flags);
222
223 return 0;
224}
225EXPORT_SYMBOL(vpe_stop);
226
227/* I've done with it thank you */
228int vpe_free(void *vpe)
229{
230 struct vpe *v = vpe;
231 struct tc *t;
232 unsigned int evpe_flags;
233
234 t = list_entry(v->tc.next, struct tc, tc);
235 if (t == NULL)
236 return -ENOEXEC;
237
238 evpe_flags = dvpe();
239
240 /* Put MVPE's into 'configuration state' */
241 set_c0_mvpcontrol(MVPCONTROL_VPC);
242
243 settc(t->index);
244 write_vpe_c0_vpeconf0(read_vpe_c0_vpeconf0() & ~VPECONF0_VPA);
245
246 /* halt the TC */
247 write_tc_c0_tchalt(TCHALT_H);
248 mips_ihb();
249
250 /* mark the TC unallocated */
251 write_tc_c0_tcstatus(read_tc_c0_tcstatus() & ~TCSTATUS_A);
252
253 v->state = VPE_STATE_UNUSED;
254
255 clear_c0_mvpcontrol(MVPCONTROL_VPC);
256 evpe(evpe_flags);
257
258 return 0;
259}
260EXPORT_SYMBOL(vpe_free);
261
262static ssize_t store_kill(struct device *dev, struct device_attribute *attr,
263 const char *buf, size_t len)
264{
265 struct vpe *vpe = get_vpe(aprp_cpu_index());
266 struct vpe_notifications *notifier;
267
268 list_for_each_entry(notifier, &vpe->notify, list)
269 notifier->stop(aprp_cpu_index());
270
271 release_progmem(vpe->load_addr);
272 cleanup_tc(get_tc(aprp_cpu_index()));
273 vpe_stop(vpe);
274 vpe_free(vpe);
275
276 return len;
277}
278static DEVICE_ATTR(kill, S_IWUSR, NULL, store_kill);
279
280static ssize_t ntcs_show(struct device *cd, struct device_attribute *attr,
281 char *buf)
282{
283 struct vpe *vpe = get_vpe(aprp_cpu_index());
284
285 return sprintf(buf, "%d\n", vpe->ntcs);
286}
287
288static ssize_t ntcs_store(struct device *dev, struct device_attribute *attr,
289 const char *buf, size_t len)
290{
291 struct vpe *vpe = get_vpe(aprp_cpu_index());
292 unsigned long new;
293 int ret;
294
295 ret = kstrtoul(buf, 0, &new);
296 if (ret < 0)
297 return ret;
298
299 if (new == 0 || new > (hw_tcs - aprp_cpu_index()))
300 return -EINVAL;
301
302 vpe->ntcs = new;
303
304 return len;
305}
306static DEVICE_ATTR_RW(ntcs);
307
308static struct attribute *vpe_attrs[] = {
309 &dev_attr_kill.attr,
310 &dev_attr_ntcs.attr,
311 NULL,
312};
313ATTRIBUTE_GROUPS(vpe);
314
315static void vpe_device_release(struct device *cd)
316{
317 kfree(cd);
318}
319
320static struct class vpe_class = {
321 .name = "vpe",
322 .owner = THIS_MODULE,
323 .dev_release = vpe_device_release,
324 .dev_groups = vpe_groups,
325};
326
327static struct device vpe_device;
328
329int __init vpe_module_init(void)
330{
331 unsigned int mtflags, vpflags;
332 unsigned long flags, val;
333 struct vpe *v = NULL;
334 struct tc *t;
335 int tc, err;
336
337 if (!cpu_has_mipsmt) {
338 pr_warn("VPE loader: not a MIPS MT capable processor\n");
339 return -ENODEV;
340 }
341
342 if (vpelimit == 0) {
343 pr_warn("No VPEs reserved for AP/SP, not initialize VPE loader\n"
344 "Pass maxvpes=<n> argument as kernel argument\n");
345
346 return -ENODEV;
347 }
348
349 if (aprp_cpu_index() == 0) {
350 pr_warn("No TCs reserved for AP/SP, not initialize VPE loader\n"
351 "Pass maxtcs=<n> argument as kernel argument\n");
352
353 return -ENODEV;
354 }
355
356 major = register_chrdev(0, VPE_MODULE_NAME, &vpe_fops);
357 if (major < 0) {
358 pr_warn("VPE loader: unable to register character device\n");
359 return major;
360 }
361
362 err = class_register(&vpe_class);
363 if (err) {
364 pr_err("vpe_class registration failed\n");
365 goto out_chrdev;
366 }
367
368 device_initialize(&vpe_device);
369 vpe_device.class = &vpe_class,
370 vpe_device.parent = NULL,
371 dev_set_name(&vpe_device, "vpe1");
372 vpe_device.devt = MKDEV(major, VPE_MODULE_MINOR);
373 err = device_add(&vpe_device);
374 if (err) {
375 pr_err("Adding vpe_device failed\n");
376 goto out_class;
377 }
378
379 local_irq_save(flags);
380 mtflags = dmt();
381 vpflags = dvpe();
382
383 /* Put MVPE's into 'configuration state' */
384 set_c0_mvpcontrol(MVPCONTROL_VPC);
385
386 val = read_c0_mvpconf0();
387 hw_tcs = (val & MVPCONF0_PTC) + 1;
388 hw_vpes = ((val & MVPCONF0_PVPE) >> MVPCONF0_PVPE_SHIFT) + 1;
389
390 for (tc = aprp_cpu_index(); tc < hw_tcs; tc++) {
391 /*
392 * Must re-enable multithreading temporarily or in case we
393 * reschedule send IPIs or similar we might hang.
394 */
395 clear_c0_mvpcontrol(MVPCONTROL_VPC);
396 evpe(vpflags);
397 emt(mtflags);
398 local_irq_restore(flags);
399 t = alloc_tc(tc);
400 if (!t) {
401 err = -ENOMEM;
402 goto out_dev;
403 }
404
405 local_irq_save(flags);
406 mtflags = dmt();
407 vpflags = dvpe();
408 set_c0_mvpcontrol(MVPCONTROL_VPC);
409
410 /* VPE's */
411 if (tc < hw_tcs) {
412 settc(tc);
413
414 v = alloc_vpe(tc);
415 if (v == NULL) {
416 pr_warn("VPE: unable to allocate VPE\n");
417 goto out_reenable;
418 }
419
420 v->ntcs = hw_tcs - aprp_cpu_index();
421
422 /* add the tc to the list of this vpe's tc's. */
423 list_add(&t->tc, &v->tc);
424
425 /* deactivate all but vpe0 */
426 if (tc >= aprp_cpu_index()) {
427 unsigned long tmp = read_vpe_c0_vpeconf0();
428
429 tmp &= ~VPECONF0_VPA;
430
431 /* master VPE */
432 tmp |= VPECONF0_MVP;
433 write_vpe_c0_vpeconf0(tmp);
434 }
435
436 /* disable multi-threading with TC's */
437 write_vpe_c0_vpecontrol(read_vpe_c0_vpecontrol() &
438 ~VPECONTROL_TE);
439
440 if (tc >= vpelimit) {
441 /*
442 * Set config to be the same as vpe0,
443 * particularly kseg0 coherency alg
444 */
445 write_vpe_c0_config(read_c0_config());
446 }
447 }
448
449 /* TC's */
450 t->pvpe = v; /* set the parent vpe */
451
452 if (tc >= aprp_cpu_index()) {
453 unsigned long tmp;
454
455 settc(tc);
456
457 /* Any TC that is bound to VPE0 gets left as is - in
458 * case we are running SMTC on VPE0. A TC that is bound
459 * to any other VPE gets bound to VPE0, ideally I'd like
460 * to make it homeless but it doesn't appear to let me
461 * bind a TC to a non-existent VPE. Which is perfectly
462 * reasonable.
463 *
464 * The (un)bound state is visible to an EJTAG probe so
465 * may notify GDB...
466 */
467 tmp = read_tc_c0_tcbind();
468 if (tmp & TCBIND_CURVPE) {
469 /* tc is bound >vpe0 */
470 write_tc_c0_tcbind(tmp & ~TCBIND_CURVPE);
471
472 t->pvpe = get_vpe(0); /* set the parent vpe */
473 }
474
475 /* halt the TC */
476 write_tc_c0_tchalt(TCHALT_H);
477 mips_ihb();
478
479 tmp = read_tc_c0_tcstatus();
480
481 /* mark not activated and not dynamically allocatable */
482 tmp &= ~(TCSTATUS_A | TCSTATUS_DA);
483 tmp |= TCSTATUS_IXMT; /* interrupt exempt */
484 write_tc_c0_tcstatus(tmp);
485 }
486 }
487
488out_reenable:
489 /* release config state */
490 clear_c0_mvpcontrol(MVPCONTROL_VPC);
491
492 evpe(vpflags);
493 emt(mtflags);
494 local_irq_restore(flags);
495
496 return 0;
497
498out_dev:
499 device_del(&vpe_device);
500
501out_class:
502 class_unregister(&vpe_class);
503
504out_chrdev:
505 unregister_chrdev(major, VPE_MODULE_NAME);
506
507 return err;
508}
509
510void __exit vpe_module_exit(void)
511{
512 struct vpe *v, *n;
513
514 device_del(&vpe_device);
515 class_unregister(&vpe_class);
516 unregister_chrdev(major, VPE_MODULE_NAME);
517
518 /* No locking needed here */
519 list_for_each_entry_safe(v, n, &vpecontrol.vpe_list, list) {
520 if (v->state != VPE_STATE_UNUSED)
521 release_vpe(v);
522 }
523}
diff --git a/arch/mips/kernel/vpe.c b/arch/mips/kernel/vpe.c
index 59b2b3cd7885..61dfd5b050ff 100644
--- a/arch/mips/kernel/vpe.c
+++ b/arch/mips/kernel/vpe.c
@@ -51,8 +51,6 @@
51#include <asm/processor.h> 51#include <asm/processor.h>
52#include <asm/vpe.h> 52#include <asm/vpe.h>
53 53
54typedef void *vpe_handle;
55
56#ifndef ARCH_SHF_SMALL 54#ifndef ARCH_SHF_SMALL
57#define ARCH_SHF_SMALL 0 55#define ARCH_SHF_SMALL 0
58#endif 56#endif
@@ -60,96 +58,15 @@ typedef void *vpe_handle;
60/* If this is set, the section belongs in the init part of the module */ 58/* If this is set, the section belongs in the init part of the module */
61#define INIT_OFFSET_MASK (1UL << (BITS_PER_LONG-1)) 59#define INIT_OFFSET_MASK (1UL << (BITS_PER_LONG-1))
62 60
63/* 61struct vpe_control vpecontrol = {
64 * The number of TCs and VPEs physically available on the core
65 */
66static int hw_tcs, hw_vpes;
67static char module_name[] = "vpe";
68static int major;
69static 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
79extern unsigned long physical_memsize;
80
81#define MAX_VPES 16
82#define VPE_PATH_MAX 256
83
84enum vpe_state {
85 VPE_STATE_UNUSED = 0,
86 VPE_STATE_INUSE,
87 VPE_STATE_RUNNING
88};
89
90enum tc_state {
91 TC_STATE_UNUSED = 0,
92 TC_STATE_INUSE,
93 TC_STATE_RUNNING,
94 TC_STATE_DYNAMIC
95};
96
97struct 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 unsigned int uid, gid;
109 char cwd[VPE_PATH_MAX];
110
111 unsigned long __start;
112
113 /* tc's associated with this vpe */
114 struct list_head tc;
115
116 /* The list of vpe's */
117 struct list_head list;
118
119 /* shared symbol address */
120 void *shared_ptr;
121
122 /* the list of who wants to know when something major happens */
123 struct list_head notify;
124
125 unsigned int ntcs;
126};
127
128struct tc {
129 enum tc_state state;
130 int index;
131
132 struct vpe *pvpe; /* parent VPE */
133 struct list_head tc; /* The list of TC's with this VPE */
134 struct list_head list; /* The global list of tc's */
135};
136
137struct {
138 spinlock_t vpe_list_lock;
139 struct list_head vpe_list; /* Virtual processing elements */
140 spinlock_t tc_list_lock;
141 struct list_head tc_list; /* Thread contexts */
142} vpecontrol = {
143 .vpe_list_lock = __SPIN_LOCK_UNLOCKED(vpe_list_lock), 62 .vpe_list_lock = __SPIN_LOCK_UNLOCKED(vpe_list_lock),
144 .vpe_list = LIST_HEAD_INIT(vpecontrol.vpe_list), 63 .vpe_list = LIST_HEAD_INIT(vpecontrol.vpe_list),
145 .tc_list_lock = __SPIN_LOCK_UNLOCKED(tc_list_lock), 64 .tc_list_lock = __SPIN_LOCK_UNLOCKED(tc_list_lock),
146 .tc_list = LIST_HEAD_INIT(vpecontrol.tc_list) 65 .tc_list = LIST_HEAD_INIT(vpecontrol.tc_list)
147}; 66};
148 67
149static void release_progmem(void *ptr);
150
151/* get the vpe associated with this minor */ 68/* get the vpe associated with this minor */
152static struct vpe *get_vpe(int minor) 69struct vpe *get_vpe(int minor)
153{ 70{
154 struct vpe *res, *v; 71 struct vpe *res, *v;
155 72
@@ -159,7 +76,7 @@ static struct vpe *get_vpe(int minor)
159 res = NULL; 76 res = NULL;
160 spin_lock(&vpecontrol.vpe_list_lock); 77 spin_lock(&vpecontrol.vpe_list_lock);
161 list_for_each_entry(v, &vpecontrol.vpe_list, list) { 78 list_for_each_entry(v, &vpecontrol.vpe_list, list) {
162 if (v->minor == minor) { 79 if (v->minor == VPE_MODULE_MINOR) {
163 res = v; 80 res = v;
164 break; 81 break;
165 } 82 }
@@ -170,7 +87,7 @@ static struct vpe *get_vpe(int minor)
170} 87}
171 88
172/* get the vpe associated with this minor */ 89/* get the vpe associated with this minor */
173static struct tc *get_tc(int index) 90struct tc *get_tc(int index)
174{ 91{
175 struct tc *res, *t; 92 struct tc *res, *t;
176 93
@@ -188,7 +105,7 @@ static struct tc *get_tc(int index)
188} 105}
189 106
190/* allocate a vpe and associate it with this minor (or index) */ 107/* allocate a vpe and associate it with this minor (or index) */
191static struct vpe *alloc_vpe(int minor) 108struct vpe *alloc_vpe(int minor)
192{ 109{
193 struct vpe *v; 110 struct vpe *v;
194 111
@@ -201,13 +118,13 @@ static struct vpe *alloc_vpe(int minor)
201 spin_unlock(&vpecontrol.vpe_list_lock); 118 spin_unlock(&vpecontrol.vpe_list_lock);
202 119
203 INIT_LIST_HEAD(&v->notify); 120 INIT_LIST_HEAD(&v->notify);
204 v->minor = minor; 121 v->minor = VPE_MODULE_MINOR;
205 122
206 return v; 123 return v;
207} 124}
208 125
209/* allocate a tc. At startup only tc0 is running, all other can be halted. */ 126/* allocate a tc. At startup only tc0 is running, all other can be halted. */
210static struct tc *alloc_tc(int index) 127struct tc *alloc_tc(int index)
211{ 128{
212 struct tc *tc; 129 struct tc *tc;
213 130
@@ -226,7 +143,7 @@ out:
226} 143}
227 144
228/* clean up and free everything */ 145/* clean up and free everything */
229static void release_vpe(struct vpe *v) 146void release_vpe(struct vpe *v)
230{ 147{
231 list_del(&v->list); 148 list_del(&v->list);
232 if (v->load_addr) 149 if (v->load_addr)
@@ -234,28 +151,8 @@ static void release_vpe(struct vpe *v)
234 kfree(v); 151 kfree(v);
235} 152}
236 153
237static void __maybe_unused dump_mtregs(void)
238{
239 unsigned long val;
240
241 val = read_c0_config3();
242 printk("config3 0x%lx MT %ld\n", val,
243 (val & CONFIG3_MT) >> CONFIG3_MT_SHIFT);
244
245 val = read_c0_mvpcontrol();
246 printk("MVPControl 0x%lx, STLB %ld VPC %ld EVP %ld\n", val,
247 (val & MVPCONTROL_STLB) >> MVPCONTROL_STLB_SHIFT,
248 (val & MVPCONTROL_VPC) >> MVPCONTROL_VPC_SHIFT,
249 (val & MVPCONTROL_EVP));
250
251 val = read_c0_mvpconf0();
252 printk("mvpconf0 0x%lx, PVPE %ld PTC %ld M %ld\n", val,
253 (val & MVPCONF0_PVPE) >> MVPCONF0_PVPE_SHIFT,
254 val & MVPCONF0_PTC, (val & MVPCONF0_M) >> MVPCONF0_M_SHIFT);
255}
256
257/* Find some VPE program space */ 154/* Find some VPE program space */
258static void *alloc_progmem(unsigned long len) 155void *alloc_progmem(unsigned long len)
259{ 156{
260 void *addr; 157 void *addr;
261 158
@@ -274,7 +171,7 @@ static void *alloc_progmem(unsigned long len)
274 return addr; 171 return addr;
275} 172}
276 173
277static void release_progmem(void *ptr) 174void release_progmem(void *ptr)
278{ 175{
279#ifndef CONFIG_MIPS_VPE_LOADER_TOM 176#ifndef CONFIG_MIPS_VPE_LOADER_TOM
280 kfree(ptr); 177 kfree(ptr);
@@ -675,127 +572,6 @@ static void dump_elfsymbols(Elf_Shdr * sechdrs, unsigned int symindex,
675} 572}
676#endif 573#endif
677 574
678/* We are prepared so configure and start the VPE... */
679static int vpe_run(struct vpe * v)
680{
681 unsigned long flags, val, dmt_flag;
682 struct vpe_notifications *n;
683 unsigned int vpeflags;
684 struct tc *t;
685
686 /* check we are the Master VPE */
687 local_irq_save(flags);
688 val = read_c0_vpeconf0();
689 if (!(val & VPECONF0_MVP)) {
690 printk(KERN_WARNING
691 "VPE loader: only Master VPE's are allowed to configure MT\n");
692 local_irq_restore(flags);
693
694 return -1;
695 }
696
697 dmt_flag = dmt();
698 vpeflags = dvpe();
699
700 if (list_empty(&v->tc)) {
701 evpe(vpeflags);
702 emt(dmt_flag);
703 local_irq_restore(flags);
704
705 printk(KERN_WARNING
706 "VPE loader: No TC's associated with VPE %d\n",
707 v->minor);
708
709 return -ENOEXEC;
710 }
711
712 t = list_first_entry(&v->tc, struct tc, tc);
713
714 /* Put MVPE's into 'configuration state' */
715 set_c0_mvpcontrol(MVPCONTROL_VPC);
716
717 settc(t->index);
718
719 /* should check it is halted, and not activated */
720 if ((read_tc_c0_tcstatus() & TCSTATUS_A) || !(read_tc_c0_tchalt() & TCHALT_H)) {
721 evpe(vpeflags);
722 emt(dmt_flag);
723 local_irq_restore(flags);
724
725 printk(KERN_WARNING "VPE loader: TC %d is already active!\n",
726 t->index);
727
728 return -ENOEXEC;
729 }
730
731 /* Write the address we want it to start running from in the TCPC register. */
732 write_tc_c0_tcrestart((unsigned long)v->__start);
733 write_tc_c0_tccontext((unsigned long)0);
734
735 /*
736 * Mark the TC as activated, not interrupt exempt and not dynamically
737 * allocatable
738 */
739 val = read_tc_c0_tcstatus();
740 val = (val & ~(TCSTATUS_DA | TCSTATUS_IXMT)) | TCSTATUS_A;
741 write_tc_c0_tcstatus(val);
742
743 write_tc_c0_tchalt(read_tc_c0_tchalt() & ~TCHALT_H);
744
745 /*
746 * The sde-kit passes 'memsize' to __start in $a3, so set something
747 * here... Or set $a3 to zero and define DFLT_STACK_SIZE and
748 * DFLT_HEAP_SIZE when you compile your program
749 */
750 mttgpr(6, v->ntcs);
751 mttgpr(7, physical_memsize);
752
753 /* set up VPE1 */
754 /*
755 * bind the TC to VPE 1 as late as possible so we only have the final
756 * VPE registers to set up, and so an EJTAG probe can trigger on it
757 */
758 write_tc_c0_tcbind((read_tc_c0_tcbind() & ~TCBIND_CURVPE) | 1);
759
760 write_vpe_c0_vpeconf0(read_vpe_c0_vpeconf0() & ~(VPECONF0_VPA));
761
762 back_to_back_c0_hazard();
763
764 /* Set up the XTC bit in vpeconf0 to point at our tc */
765 write_vpe_c0_vpeconf0( (read_vpe_c0_vpeconf0() & ~(VPECONF0_XTC))
766 | (t->index << VPECONF0_XTC_SHIFT));
767
768 back_to_back_c0_hazard();
769
770 /* enable this VPE */
771 write_vpe_c0_vpeconf0(read_vpe_c0_vpeconf0() | VPECONF0_VPA);
772
773 /* clear out any left overs from a previous program */
774 write_vpe_c0_status(0);
775 write_vpe_c0_cause(0);
776
777 /* take system out of configuration state */
778 clear_c0_mvpcontrol(MVPCONTROL_VPC);
779
780 /*
781 * SMTC/SMVP kernels manage VPE enable independently,
782 * but uniprocessor kernels need to turn it on, even
783 * if that wasn't the pre-dvpe() state.
784 */
785#ifdef CONFIG_SMP
786 evpe(vpeflags);
787#else
788 evpe(EVPE_ENABLE);
789#endif
790 emt(dmt_flag);
791 local_irq_restore(flags);
792
793 list_for_each_entry(n, &v->notify, list)
794 n->start(minor);
795
796 return 0;
797}
798
799static int find_vpe_symbols(struct vpe * v, Elf_Shdr * sechdrs, 575static int find_vpe_symbols(struct vpe * v, Elf_Shdr * sechdrs,
800 unsigned int symindex, const char *strtab, 576 unsigned int symindex, const char *strtab,
801 struct module *mod) 577 struct module *mod)
@@ -993,38 +769,6 @@ static int vpe_elfload(struct vpe * v)
993 return 0; 769 return 0;
994} 770}
995 771
996static void cleanup_tc(struct tc *tc)
997{
998 unsigned long flags;
999 unsigned int mtflags, vpflags;
1000 int tmp;
1001
1002 local_irq_save(flags);
1003 mtflags = dmt();
1004 vpflags = dvpe();
1005 /* Put MVPE's into 'configuration state' */
1006 set_c0_mvpcontrol(MVPCONTROL_VPC);
1007
1008 settc(tc->index);
1009 tmp = read_tc_c0_tcstatus();
1010
1011 /* mark not allocated and not dynamically allocatable */
1012 tmp &= ~(TCSTATUS_A | TCSTATUS_DA);
1013 tmp |= TCSTATUS_IXMT; /* interrupt exempt */
1014 write_tc_c0_tcstatus(tmp);
1015
1016 write_tc_c0_tchalt(TCHALT_H);
1017 mips_ihb();
1018
1019 /* bind it to anything other than VPE1 */
1020// write_tc_c0_tcbind(read_tc_c0_tcbind() & ~TCBIND_CURVPE); // | TCBIND_CURVPE
1021
1022 clear_c0_mvpcontrol(MVPCONTROL_VPC);
1023 evpe(vpflags);
1024 emt(mtflags);
1025 local_irq_restore(flags);
1026}
1027
1028static int getcwd(char *buff, int size) 772static int getcwd(char *buff, int size)
1029{ 773{
1030 mm_segment_t old_fs; 774 mm_segment_t old_fs;
@@ -1048,14 +792,14 @@ static int vpe_open(struct inode *inode, struct file *filp)
1048 struct vpe *v; 792 struct vpe *v;
1049 int ret; 793 int ret;
1050 794
1051 if (minor != iminor(inode)) { 795 if (VPE_MODULE_MINOR != iminor(inode)) {
1052 /* assume only 1 device at the moment. */ 796 /* assume only 1 device at the moment. */
1053 pr_warning("VPE loader: only vpe1 is supported\n"); 797 pr_warning("VPE loader: only vpe1 is supported\n");
1054 798
1055 return -ENODEV; 799 return -ENODEV;
1056 } 800 }
1057 801
1058 if ((v = get_vpe(tclimit)) == NULL) { 802 if ((v = get_vpe(aprp_cpu_index())) == NULL) {
1059 pr_warning("VPE loader: unable to get vpe\n"); 803 pr_warning("VPE loader: unable to get vpe\n");
1060 804
1061 return -ENODEV; 805 return -ENODEV;
@@ -1066,11 +810,11 @@ static int vpe_open(struct inode *inode, struct file *filp)
1066 printk(KERN_DEBUG "VPE loader: tc in use dumping regs\n"); 810 printk(KERN_DEBUG "VPE loader: tc in use dumping regs\n");
1067 811
1068 list_for_each_entry(not, &v->notify, list) { 812 list_for_each_entry(not, &v->notify, list) {
1069 not->stop(tclimit); 813 not->stop(aprp_cpu_index());
1070 } 814 }
1071 815
1072 release_progmem(v->load_addr); 816 release_progmem(v->load_addr);
1073 cleanup_tc(get_tc(tclimit)); 817 cleanup_tc(get_tc(aprp_cpu_index()));
1074 } 818 }
1075 819
1076 /* this of-course trashes what was there before... */ 820 /* this of-course trashes what was there before... */
@@ -1103,13 +847,13 @@ static int vpe_release(struct inode *inode, struct file *filp)
1103 Elf_Ehdr *hdr; 847 Elf_Ehdr *hdr;
1104 int ret = 0; 848 int ret = 0;
1105 849
1106 v = get_vpe(tclimit); 850 v = get_vpe(aprp_cpu_index());
1107 if (v == NULL) 851 if (v == NULL)
1108 return -ENODEV; 852 return -ENODEV;
1109 853
1110 hdr = (Elf_Ehdr *) v->pbuffer; 854 hdr = (Elf_Ehdr *) v->pbuffer;
1111 if (memcmp(hdr->e_ident, ELFMAG, SELFMAG) == 0) { 855 if (memcmp(hdr->e_ident, ELFMAG, SELFMAG) == 0) {
1112 if (vpe_elfload(v) >= 0) { 856 if ((vpe_elfload(v) >= 0) && vpe_run) {
1113 vpe_run(v); 857 vpe_run(v);
1114 } else { 858 } else {
1115 printk(KERN_WARNING "VPE loader: ELF load failed.\n"); 859 printk(KERN_WARNING "VPE loader: ELF load failed.\n");
@@ -1140,10 +884,10 @@ static ssize_t vpe_write(struct file *file, const char __user * buffer,
1140 size_t ret = count; 884 size_t ret = count;
1141 struct vpe *v; 885 struct vpe *v;
1142 886
1143 if (iminor(file_inode(file)) != minor) 887 if (iminor(file_inode(file)) != VPE_MODULE_MINOR)
1144 return -ENODEV; 888 return -ENODEV;
1145 889
1146 v = get_vpe(tclimit); 890 v = get_vpe(aprp_cpu_index());
1147 if (v == NULL) 891 if (v == NULL)
1148 return -ENODEV; 892 return -ENODEV;
1149 893
@@ -1161,7 +905,7 @@ static ssize_t vpe_write(struct file *file, const char __user * buffer,
1161 return ret; 905 return ret;
1162} 906}
1163 907
1164static const struct file_operations vpe_fops = { 908const struct file_operations vpe_fops = {
1165 .owner = THIS_MODULE, 909 .owner = THIS_MODULE,
1166 .open = vpe_open, 910 .open = vpe_open,
1167 .release = vpe_release, 911 .release = vpe_release,
@@ -1169,94 +913,6 @@ static const struct file_operations vpe_fops = {
1169 .llseek = noop_llseek, 913 .llseek = noop_llseek,
1170}; 914};
1171 915
1172/* module wrapper entry points */
1173/* give me a vpe */
1174vpe_handle vpe_alloc(void)
1175{
1176 int i;
1177 struct vpe *v;
1178
1179 /* find a vpe */
1180 for (i = 1; i < MAX_VPES; i++) {
1181 if ((v = get_vpe(i)) != NULL) {
1182 v->state = VPE_STATE_INUSE;
1183 return v;
1184 }
1185 }
1186 return NULL;
1187}
1188
1189EXPORT_SYMBOL(vpe_alloc);
1190
1191/* start running from here */
1192int vpe_start(vpe_handle vpe, unsigned long start)
1193{
1194 struct vpe *v = vpe;
1195
1196 v->__start = start;
1197 return vpe_run(v);
1198}
1199
1200EXPORT_SYMBOL(vpe_start);
1201
1202/* halt it for now */
1203int vpe_stop(vpe_handle vpe)
1204{
1205 struct vpe *v = vpe;
1206 struct tc *t;
1207 unsigned int evpe_flags;
1208
1209 evpe_flags = dvpe();
1210
1211 if ((t = list_entry(v->tc.next, struct tc, tc)) != NULL) {
1212
1213 settc(t->index);
1214 write_vpe_c0_vpeconf0(read_vpe_c0_vpeconf0() & ~VPECONF0_VPA);
1215 }
1216
1217 evpe(evpe_flags);
1218
1219 return 0;
1220}
1221
1222EXPORT_SYMBOL(vpe_stop);
1223
1224/* I've done with it thank you */
1225int vpe_free(vpe_handle vpe)
1226{
1227 struct vpe *v = vpe;
1228 struct tc *t;
1229 unsigned int evpe_flags;
1230
1231 if ((t = list_entry(v->tc.next, struct tc, tc)) == NULL) {
1232 return -ENOEXEC;
1233 }
1234
1235 evpe_flags = dvpe();
1236
1237 /* Put MVPE's into 'configuration state' */
1238 set_c0_mvpcontrol(MVPCONTROL_VPC);
1239
1240 settc(t->index);
1241 write_vpe_c0_vpeconf0(read_vpe_c0_vpeconf0() & ~VPECONF0_VPA);
1242
1243 /* halt the TC */
1244 write_tc_c0_tchalt(TCHALT_H);
1245 mips_ihb();
1246
1247 /* mark the TC unallocated */
1248 write_tc_c0_tcstatus(read_tc_c0_tcstatus() & ~TCSTATUS_A);
1249
1250 v->state = VPE_STATE_UNUSED;
1251
1252 clear_c0_mvpcontrol(MVPCONTROL_VPC);
1253 evpe(evpe_flags);
1254
1255 return 0;
1256}
1257
1258EXPORT_SYMBOL(vpe_free);
1259
1260void *vpe_get_shared(int index) 916void *vpe_get_shared(int index)
1261{ 917{
1262 struct vpe *v; 918 struct vpe *v;
@@ -1318,271 +974,6 @@ char *vpe_getcwd(int index)
1318 974
1319EXPORT_SYMBOL(vpe_getcwd); 975EXPORT_SYMBOL(vpe_getcwd);
1320 976
1321static ssize_t store_kill(struct device *dev, struct device_attribute *attr,
1322 const char *buf, size_t len)
1323{
1324 struct vpe *vpe = get_vpe(tclimit);
1325 struct vpe_notifications *not;
1326
1327 list_for_each_entry(not, &vpe->notify, list) {
1328 not->stop(tclimit);
1329 }
1330
1331 release_progmem(vpe->load_addr);
1332 cleanup_tc(get_tc(tclimit));
1333 vpe_stop(vpe);
1334 vpe_free(vpe);
1335
1336 return len;
1337}
1338static DEVICE_ATTR(kill, S_IWUSR, NULL, store_kill);
1339
1340static ssize_t ntcs_show(struct device *cd, struct device_attribute *attr,
1341 char *buf)
1342{
1343 struct vpe *vpe = get_vpe(tclimit);
1344
1345 return sprintf(buf, "%d\n", vpe->ntcs);
1346}
1347
1348static ssize_t ntcs_store(struct device *dev, struct device_attribute *attr,
1349 const char *buf, size_t len)
1350{
1351 struct vpe *vpe = get_vpe(tclimit);
1352 unsigned long new;
1353 char *endp;
1354
1355 new = simple_strtoul(buf, &endp, 0);
1356 if (endp == buf)
1357 goto out_einval;
1358
1359 if (new == 0 || new > (hw_tcs - tclimit))
1360 goto out_einval;
1361
1362 vpe->ntcs = new;
1363
1364 return len;
1365
1366out_einval:
1367 return -EINVAL;
1368}
1369static DEVICE_ATTR_RW(ntcs);
1370
1371static struct attribute *vpe_attrs[] = {
1372 &dev_attr_kill.attr,
1373 &dev_attr_ntcs.attr,
1374 NULL,
1375};
1376ATTRIBUTE_GROUPS(vpe);
1377
1378static void vpe_device_release(struct device *cd)
1379{
1380 kfree(cd);
1381}
1382
1383struct class vpe_class = {
1384 .name = "vpe",
1385 .owner = THIS_MODULE,
1386 .dev_release = vpe_device_release,
1387 .dev_groups = vpe_groups,
1388};
1389
1390struct device vpe_device;
1391
1392static int __init vpe_module_init(void)
1393{
1394 unsigned int mtflags, vpflags;
1395 unsigned long flags, val;
1396 struct vpe *v = NULL;
1397 struct tc *t;
1398 int tc, err;
1399
1400 if (!cpu_has_mipsmt) {
1401 printk("VPE loader: not a MIPS MT capable processor\n");
1402 return -ENODEV;
1403 }
1404
1405 if (vpelimit == 0) {
1406 printk(KERN_WARNING "No VPEs reserved for AP/SP, not "
1407 "initializing VPE loader.\nPass maxvpes=<n> argument as "
1408 "kernel argument\n");
1409
1410 return -ENODEV;
1411 }
1412
1413 if (tclimit == 0) {
1414 printk(KERN_WARNING "No TCs reserved for AP/SP, not "
1415 "initializing VPE loader.\nPass maxtcs=<n> argument as "
1416 "kernel argument\n");
1417
1418 return -ENODEV;
1419 }
1420
1421 major = register_chrdev(0, module_name, &vpe_fops);
1422 if (major < 0) {
1423 printk("VPE loader: unable to register character device\n");
1424 return major;
1425 }
1426
1427 err = class_register(&vpe_class);
1428 if (err) {
1429 printk(KERN_ERR "vpe_class registration failed\n");
1430 goto out_chrdev;
1431 }
1432
1433 device_initialize(&vpe_device);
1434 vpe_device.class = &vpe_class,
1435 vpe_device.parent = NULL,
1436 dev_set_name(&vpe_device, "vpe1");
1437 vpe_device.devt = MKDEV(major, minor);
1438 err = device_add(&vpe_device);
1439 if (err) {
1440 printk(KERN_ERR "Adding vpe_device failed\n");
1441 goto out_class;
1442 }
1443
1444 local_irq_save(flags);
1445 mtflags = dmt();
1446 vpflags = dvpe();
1447
1448 /* Put MVPE's into 'configuration state' */
1449 set_c0_mvpcontrol(MVPCONTROL_VPC);
1450
1451 /* dump_mtregs(); */
1452
1453 val = read_c0_mvpconf0();
1454 hw_tcs = (val & MVPCONF0_PTC) + 1;
1455 hw_vpes = ((val & MVPCONF0_PVPE) >> MVPCONF0_PVPE_SHIFT) + 1;
1456
1457 for (tc = tclimit; tc < hw_tcs; tc++) {
1458 /*
1459 * Must re-enable multithreading temporarily or in case we
1460 * reschedule send IPIs or similar we might hang.
1461 */
1462 clear_c0_mvpcontrol(MVPCONTROL_VPC);
1463 evpe(vpflags);
1464 emt(mtflags);
1465 local_irq_restore(flags);
1466 t = alloc_tc(tc);
1467 if (!t) {
1468 err = -ENOMEM;
1469 goto out;
1470 }
1471
1472 local_irq_save(flags);
1473 mtflags = dmt();
1474 vpflags = dvpe();
1475 set_c0_mvpcontrol(MVPCONTROL_VPC);
1476
1477 /* VPE's */
1478 if (tc < hw_tcs) {
1479 settc(tc);
1480
1481 if ((v = alloc_vpe(tc)) == NULL) {
1482 printk(KERN_WARNING "VPE: unable to allocate VPE\n");
1483
1484 goto out_reenable;
1485 }
1486
1487 v->ntcs = hw_tcs - tclimit;
1488
1489 /* add the tc to the list of this vpe's tc's. */
1490 list_add(&t->tc, &v->tc);
1491
1492 /* deactivate all but vpe0 */
1493 if (tc >= tclimit) {
1494 unsigned long tmp = read_vpe_c0_vpeconf0();
1495
1496 tmp &= ~VPECONF0_VPA;
1497
1498 /* master VPE */
1499 tmp |= VPECONF0_MVP;
1500 write_vpe_c0_vpeconf0(tmp);
1501 }
1502
1503 /* disable multi-threading with TC's */
1504 write_vpe_c0_vpecontrol(read_vpe_c0_vpecontrol() & ~VPECONTROL_TE);
1505
1506 if (tc >= vpelimit) {
1507 /*
1508 * Set config to be the same as vpe0,
1509 * particularly kseg0 coherency alg
1510 */
1511 write_vpe_c0_config(read_c0_config());
1512 }
1513 }
1514
1515 /* TC's */
1516 t->pvpe = v; /* set the parent vpe */
1517
1518 if (tc >= tclimit) {
1519 unsigned long tmp;
1520
1521 settc(tc);
1522
1523 /* Any TC that is bound to VPE0 gets left as is - in case
1524 we are running SMTC on VPE0. A TC that is bound to any
1525 other VPE gets bound to VPE0, ideally I'd like to make
1526 it homeless but it doesn't appear to let me bind a TC
1527 to a non-existent VPE. Which is perfectly reasonable.
1528
1529 The (un)bound state is visible to an EJTAG probe so may
1530 notify GDB...
1531 */
1532
1533 if (((tmp = read_tc_c0_tcbind()) & TCBIND_CURVPE)) {
1534 /* tc is bound >vpe0 */
1535 write_tc_c0_tcbind(tmp & ~TCBIND_CURVPE);
1536
1537 t->pvpe = get_vpe(0); /* set the parent vpe */
1538 }
1539
1540 /* halt the TC */
1541 write_tc_c0_tchalt(TCHALT_H);
1542 mips_ihb();
1543
1544 tmp = read_tc_c0_tcstatus();
1545
1546 /* mark not activated and not dynamically allocatable */
1547 tmp &= ~(TCSTATUS_A | TCSTATUS_DA);
1548 tmp |= TCSTATUS_IXMT; /* interrupt exempt */
1549 write_tc_c0_tcstatus(tmp);
1550 }
1551 }
1552
1553out_reenable:
1554 /* release config state */
1555 clear_c0_mvpcontrol(MVPCONTROL_VPC);
1556
1557 evpe(vpflags);
1558 emt(mtflags);
1559 local_irq_restore(flags);
1560
1561 return 0;
1562
1563out_class:
1564 class_unregister(&vpe_class);
1565out_chrdev:
1566 unregister_chrdev(major, module_name);
1567
1568out:
1569 return err;
1570}
1571
1572static void __exit vpe_module_exit(void)
1573{
1574 struct vpe *v, *n;
1575
1576 device_del(&vpe_device);
1577 unregister_chrdev(major, module_name);
1578
1579 /* No locking needed here */
1580 list_for_each_entry_safe(v, n, &vpecontrol.vpe_list, list) {
1581 if (v->state != VPE_STATE_UNUSED)
1582 release_vpe(v);
1583 }
1584}
1585
1586module_init(vpe_module_init); 977module_init(vpe_module_init);
1587module_exit(vpe_module_exit); 978module_exit(vpe_module_exit);
1588MODULE_DESCRIPTION("MIPS VPE Loader"); 979MODULE_DESCRIPTION("MIPS VPE Loader");
generated by cgit v1.2.2 (git 2.25.0) at 2025-03-10 03:28:35 -0400