projects / openwrt / svn-archive / archive.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[lantiq]
[openwrt/svn-archive/archive.git] / target / linux / lantiq / patches-2.6.39 / 250-mt-vpe.patch
1 --- a/arch/mips/Kconfig
2 +++ b/arch/mips/Kconfig
3 @@ -1871,6 +1871,28 @@
4 Includes a loader for loading an elf relocatable object
5 onto another VPE and running it.
6
7 +config IFX_VPE_EXT
8 + bool "IFX APRP Extensions"
9 + depends on MIPS_VPE_LOADER
10 + default y
11 + help
12 + IFX included extensions in APRP
13 +
14 +config PERFCTRS
15 + bool "34K Performance counters"
16 + depends on MIPS_MT && PROC_FS
17 + default n
18 + help
19 + 34K Performance counter through /proc
20 +
21 +config MTSCHED
22 + bool "Support mtsched priority configuration for TCs"
23 + depends on MIPS_MT && PROC_FS
24 + default y
25 + help
26 + Support for mtsched priority configuration for TCs through
27 + /proc/mips/mtsched
28 +
29 config MIPS_MT_SMTC_IM_BACKSTOP
30 bool "Use per-TC register bits as backstop for inhibited IM bits"
31 depends on MIPS_MT_SMTC
32 --- a/arch/mips/include/asm/mipsmtregs.h
33 +++ b/arch/mips/include/asm/mipsmtregs.h
34 @@ -28,14 +28,34 @@
35 #define read_c0_vpeconf0() __read_32bit_c0_register($1, 2)
36 #define write_c0_vpeconf0(val) __write_32bit_c0_register($1, 2, val)
37
38 +#define read_c0_vpeconf1() __read_32bit_c0_register($1, 3)
39 +#define write_c0_vpeconf1(val) __write_32bit_c0_register($1, 3, val)
40 +
41 +#define read_c0_vpeschedule() __read_32bit_c0_register($1, 5)
42 +#define write_c0_vpeschedule(val) __write_32bit_c0_register($1, 5, val)
43 +
44 +#define read_c0_vpeschefback() __read_32bit_c0_register($1, 6)
45 +#define write_c0_vpeschefback(val) __write_32bit_c0_register($1, 6, val)
46 +
47 +#define read_c0_vpeopt() __read_32bit_c0_register($1, 7)
48 +#define write_c0_vpeopt(val) __write_32bit_c0_register($1, 7, val)
49 +
50 #define read_c0_tcstatus() __read_32bit_c0_register($2, 1)
51 #define write_c0_tcstatus(val) __write_32bit_c0_register($2, 1, val)
52
53 #define read_c0_tcbind() __read_32bit_c0_register($2, 2)
54 +#define write_c0_tcbind(val) __write_32bit_c0_register($2, 2, val)
55
56 #define read_c0_tccontext() __read_32bit_c0_register($2, 5)
57 #define write_c0_tccontext(val) __write_32bit_c0_register($2, 5, val)
58
59 +#define read_c0_tcschedule() __read_32bit_c0_register($2, 6)
60 +#define write_c0_tcschedule(val) __write_32bit_c0_register($2, 6, val)
61 +
62 +#define read_c0_tcschefback() __read_32bit_c0_register($2, 7)
63 +#define write_c0_tcschefback(val) __write_32bit_c0_register($2, 7, val)
64 +
65 +
66 #else /* Assembly */
67 /*
68 * Macros for use in assembly language code
69 @@ -74,6 +94,8 @@
70 #define MVPCONTROL_STLB_SHIFT 2
71 #define MVPCONTROL_STLB (_ULCAST_(1) << MVPCONTROL_STLB_SHIFT)
72
73 +#define MVPCONTROL_CPA_SHIFT 3
74 +#define MVPCONTROL_CPA (_ULCAST_(1) << MVPCONTROL_CPA_SHIFT)
75
76 /* MVPConf0 fields */
77 #define MVPCONF0_PTC_SHIFT 0
78 @@ -84,6 +106,8 @@
79 #define MVPCONF0_TCA ( _ULCAST_(1) << MVPCONF0_TCA_SHIFT)
80 #define MVPCONF0_PTLBE_SHIFT 16
81 #define MVPCONF0_PTLBE (_ULCAST_(0x3ff) << MVPCONF0_PTLBE_SHIFT)
82 +#define MVPCONF0_PCP_SHIFT 27
83 +#define MVPCONF0_PCP (_ULCAST_(1) << MVPCONF0_PCP_SHIFT)
84 #define MVPCONF0_TLBS_SHIFT 29
85 #define MVPCONF0_TLBS (_ULCAST_(1) << MVPCONF0_TLBS_SHIFT)
86 #define MVPCONF0_M_SHIFT 31
87 @@ -121,9 +145,25 @@
88 #define VPECONF0_VPA (_ULCAST_(1) << VPECONF0_VPA_SHIFT)
89 #define VPECONF0_MVP_SHIFT 1
90 #define VPECONF0_MVP (_ULCAST_(1) << VPECONF0_MVP_SHIFT)
91 +#define VPECONF0_ICS_SHIFT 16
92 +#define VPECONF0_ICS (_ULCAST_(1) << VPECONF0_ICS_SHIFT)
93 +#define VPECONF0_DCS_SHIFT 17
94 +#define VPECONF0_DCS (_ULCAST_(1) << VPECONF0_DCS_SHIFT)
95 #define VPECONF0_XTC_SHIFT 21
96 #define VPECONF0_XTC (_ULCAST_(0xff) << VPECONF0_XTC_SHIFT)
97
98 +/* VPEOpt fields */
99 +#define VPEOPT_DWX_SHIFT 0
100 +#define VPEOPT_IWX_SHIFT 8
101 +#define VPEOPT_IWX0 ( _ULCAST_(0x1) << VPEOPT_IWX_SHIFT)
102 +#define VPEOPT_IWX1 ( _ULCAST_(0x2) << VPEOPT_IWX_SHIFT)
103 +#define VPEOPT_IWX2 ( _ULCAST_(0x4) << VPEOPT_IWX_SHIFT)
104 +#define VPEOPT_IWX3 ( _ULCAST_(0x8) << VPEOPT_IWX_SHIFT)
105 +#define VPEOPT_DWX0 ( _ULCAST_(0x1) << VPEOPT_DWX_SHIFT)
106 +#define VPEOPT_DWX1 ( _ULCAST_(0x2) << VPEOPT_DWX_SHIFT)
107 +#define VPEOPT_DWX2 ( _ULCAST_(0x4) << VPEOPT_DWX_SHIFT)
108 +#define VPEOPT_DWX3 ( _ULCAST_(0x8) << VPEOPT_DWX_SHIFT)
109 +
110 /* TCStatus fields (per TC) */
111 #define TCSTATUS_TASID (_ULCAST_(0xff))
112 #define TCSTATUS_IXMT_SHIFT 10
113 @@ -350,6 +390,14 @@
114 #define write_vpe_c0_vpecontrol(val) mttc0(1, 1, val)
115 #define read_vpe_c0_vpeconf0() mftc0(1, 2)
116 #define write_vpe_c0_vpeconf0(val) mttc0(1, 2, val)
117 +#define read_vpe_c0_vpeschedule() mftc0(1, 5)
118 +#define write_vpe_c0_vpeschedule(val) mttc0(1, 5, val)
119 +#define read_vpe_c0_vpeschefback() mftc0(1, 6)
120 +#define write_vpe_c0_vpeschefback(val) mttc0(1, 6, val)
121 +#define read_vpe_c0_vpeopt() mftc0(1, 7)
122 +#define write_vpe_c0_vpeopt(val) mttc0(1, 7, val)
123 +#define read_vpe_c0_wired() mftc0(6, 0)
124 +#define write_vpe_c0_wired(val) mttc0(6, 0, val)
125 #define read_vpe_c0_count() mftc0(9, 0)
126 #define write_vpe_c0_count(val) mttc0(9, 0, val)
127 #define read_vpe_c0_status() mftc0(12, 0)
128 @@ -381,6 +429,12 @@
129 #define write_tc_c0_tchalt(val) mttc0(2, 4, val)
130 #define read_tc_c0_tccontext() mftc0(2, 5)
131 #define write_tc_c0_tccontext(val) mttc0(2, 5, val)
132 +#define read_tc_c0_tcschedule() mftc0(2, 6)
133 +#define write_tc_c0_tcschedule(val) mttc0(2, 6, val)
134 +#define read_tc_c0_tcschefback() mftc0(2, 7)
135 +#define write_tc_c0_tcschefback(val) mttc0(2, 7, val)
136 +#define read_tc_c0_entryhi() mftc0(10, 0)
137 +#define write_tc_c0_entryhi(val) mttc0(10, 0, val)
138
139 /* GPR */
140 #define read_tc_gpr_sp() mftgpr(29)
141 --- a/arch/mips/kernel/Makefile
142 +++ b/arch/mips/kernel/Makefile
143 @@ -85,7 +85,8 @@
144
145 obj-$(CONFIG_KGDB) += kgdb.o
146 obj-$(CONFIG_PROC_FS) += proc.o
147 -
148 +obj-$(CONFIG_MTSCHED) += mtsched_proc.o
149 +obj-$(CONFIG_PERFCTRS) += perf_proc.o
150 obj-$(CONFIG_64BIT) += cpu-bugs64.o
151
152 obj-$(CONFIG_I8253) += i8253.o
153 --- a/arch/mips/kernel/mips-mt.c
154 +++ b/arch/mips/kernel/mips-mt.c
155 @@ -21,26 +21,96 @@
156 #include <asm/cacheflush.h>
157
158 int vpelimit;
159 -
160 static int __init maxvpes(char *str)
161 {
162 get_option(&str, &vpelimit);
163 -
164 return 1;
165 }
166 -
167 __setup("maxvpes=", maxvpes);
168
169 int tclimit;
170 -
171 static int __init maxtcs(char *str)
172 {
173 get_option(&str, &tclimit);
174 + return 1;
175 +}
176 +__setup("maxtcs=", maxtcs);
177
178 +#ifdef CONFIG_IFX_VPE_EXT
179 +int stlb;
180 +static int __init istlbshared(char *str)
181 +{
182 + get_option(&str, &stlb);
183 return 1;
184 }
185 +__setup("vpe_tlb_shared=", istlbshared);
186
187 -__setup("maxtcs=", maxtcs);
188 +int vpe0_wired;
189 +static int __init vpe0wired(char *str)
190 +{
191 + get_option(&str, &vpe0_wired);
192 + return 1;
193 +}
194 +__setup("vpe0_wired_tlb_entries=", vpe0wired);
195 +
196 +int vpe1_wired;
197 +static int __init vpe1wired(char *str)
198 +{
199 + get_option(&str, &vpe1_wired);
200 + return 1;
201 +}
202 +__setup("vpe1_wired_tlb_entries=", vpe1wired);
203 +
204 +#ifdef CONFIG_MIPS_MT_SMTC
205 +extern int nostlb;
206 +#endif
207 +void configure_tlb(void)
208 +{
209 + int vpeflags, tcflags, tlbsiz;
210 + unsigned int config1val;
211 + vpeflags = dvpe();
212 + tcflags = dmt();
213 + write_c0_vpeconf0((read_c0_vpeconf0() | VPECONF0_MVP));
214 + write_c0_mvpcontrol((read_c0_mvpcontrol() | MVPCONTROL_VPC));
215 + mips_ihb();
216 + //printk("stlb = %d, vpe0_wired = %d vpe1_wired=%d\n", stlb,vpe0_wired, vpe1_wired);
217 + if (stlb) {
218 + if (!(read_c0_mvpconf0() & MVPCONF0_TLBS)) {
219 + emt(tcflags);
220 + evpe(vpeflags);
221 + return;
222 + }
223 +
224 + write_c0_mvpcontrol(read_c0_mvpcontrol() | MVPCONTROL_STLB);
225 + write_c0_wired(vpe0_wired + vpe1_wired);
226 + if (((read_vpe_c0_config() & MIPS_CONF_MT) >> 7) == 1) {
227 + config1val = read_vpe_c0_config1();
228 + tlbsiz = (((config1val >> 25) & 0x3f) + 1);
229 + if (tlbsiz > 64)
230 + tlbsiz = 64;
231 + cpu_data[0].tlbsize = tlbsiz;
232 + current_cpu_data.tlbsize = tlbsiz;
233 + }
234 +
235 + }
236 + else {
237 + write_c0_mvpcontrol(read_c0_mvpcontrol() & ~MVPCONTROL_STLB);
238 + write_c0_wired(vpe0_wired);
239 + }
240 +
241 + ehb();
242 + write_c0_mvpcontrol((read_c0_mvpcontrol() & ~MVPCONTROL_VPC));
243 + ehb();
244 + local_flush_tlb_all();
245 +
246 + printk("Wired TLB entries for Linux read_c0_wired() = %d\n", read_c0_wired());
247 +#ifdef CONFIG_MIPS_MT_SMTC
248 + nostlb = !stlb;
249 +#endif
250 + emt(tcflags);
251 + evpe(vpeflags);
252 +}
253 +#endif
254
255 /*
256 * Dump new MIPS MT state for the core. Does not leave TCs halted.
257 @@ -78,18 +148,18 @@
258 if ((read_tc_c0_tcbind() & TCBIND_CURVPE) == i) {
259 printk(" VPE %d\n", i);
260 printk(" VPEControl : %08lx\n",
261 - read_vpe_c0_vpecontrol());
262 + read_vpe_c0_vpecontrol());
263 printk(" VPEConf0 : %08lx\n",
264 - read_vpe_c0_vpeconf0());
265 + read_vpe_c0_vpeconf0());
266 printk(" VPE%d.Status : %08lx\n",
267 - i, read_vpe_c0_status());
268 + i, read_vpe_c0_status());
269 printk(" VPE%d.EPC : %08lx %pS\n",
270 - i, read_vpe_c0_epc(),
271 - (void *) read_vpe_c0_epc());
272 + i, read_vpe_c0_epc(),
273 + (void *) read_vpe_c0_epc());
274 printk(" VPE%d.Cause : %08lx\n",
275 - i, read_vpe_c0_cause());
276 + i, read_vpe_c0_cause());
277 printk(" VPE%d.Config7 : %08lx\n",
278 - i, read_vpe_c0_config7());
279 + i, read_vpe_c0_config7());
280 break; /* Next VPE */
281 }
282 }
283 @@ -287,6 +357,9 @@
284 printk("Mapped %ld ITC cells starting at 0x%08x\n",
285 ((itcblkgrn & 0x7fe00000) >> 20), itc_base);
286 }
287 +#ifdef CONFIG_IFX_VPE_EXT
288 + configure_tlb();
289 +#endif
290 }
291
292 /*
293 --- a/arch/mips/kernel/proc.c
294 +++ b/arch/mips/kernel/proc.c
295 @@ -7,6 +7,7 @@
296 #include <linux/kernel.h>
297 #include <linux/sched.h>
298 #include <linux/seq_file.h>
299 +#include <linux/proc_fs.h>
300 #include <asm/bootinfo.h>
301 #include <asm/cpu.h>
302 #include <asm/cpu-features.h>
303 @@ -110,3 +111,19 @@
304 .stop = c_stop,
305 .show = show_cpuinfo,
306 };
307 +
308 +/*
309 + * Support for MIPS/local /proc hooks in /proc/mips/
310 + */
311 +
312 +static struct proc_dir_entry *mips_proc = NULL;
313 +
314 +struct proc_dir_entry *get_mips_proc_dir(void)
315 +{
316 + /*
317 + * This ought not to be preemptable.
318 + */
319 + if(mips_proc == NULL)
320 + mips_proc = proc_mkdir("mips", NULL);
321 + return(mips_proc);
322 +}
323 --- a/arch/mips/kernel/smtc.c
324 +++ b/arch/mips/kernel/smtc.c
325 @@ -1334,6 +1334,13 @@
326 asid = asid_cache(cpu);
327
328 do {
329 +#ifdef CONFIG_IFX_VPE_EXT
330 + /* If TLB is shared between AP and RP (AP is running SMTC),
331 + leave out max ASID i.e., ASID_MASK for RP
332 + */
333 + if (!nostlb && ((asid & ASID_MASK) == (ASID_MASK - 1)))
334 + asid++;
335 +#endif
336 if (!((asid += ASID_INC) & ASID_MASK) ) {
337 if (cpu_has_vtag_icache)
338 flush_icache_all();
339 --- a/arch/mips/kernel/vpe.c
340 +++ b/arch/mips/kernel/vpe.c
341 @@ -76,6 +76,58 @@
342 static int kspd_events_reqd;
343 #endif
344
345 +#ifdef CONFIG_IFX_VPE_EXT
346 +static int is_sdepgm;
347 +extern int stlb;
348 +extern int vpe0_wired;
349 +extern int vpe1_wired;
350 +unsigned int vpe1_load_addr;
351 +
352 +static int __init load_address(char *str)
353 +{
354 + get_option(&str, &vpe1_load_addr);
355 + return 1;
356 +}
357 +__setup("vpe1_load_addr=", load_address);
358 +
359 +#include <asm/mipsmtregs.h>
360 +#define write_vpe_c0_wired(val) mttc0(6, 0, val)
361 +
362 +#ifndef COMMAND_LINE_SIZE
363 +# define COMMAND_LINE_SIZE 512
364 +#endif
365 +
366 +char command_line[COMMAND_LINE_SIZE * 2];
367 +
368 +static unsigned int vpe1_mem;
369 +static int __init vpe1mem(char *str)
370 +{
371 + vpe1_mem = memparse(str, &str);
372 + return 1;
373 +}
374 +__setup("vpe1_mem=", vpe1mem);
375 +
376 +uint32_t vpe1_wdog_ctr;
377 +static int __init wdog_ctr(char *str)
378 +{
379 + get_option(&str, &vpe1_wdog_ctr);
380 + return 1;
381 +}
382 +
383 +__setup("vpe1_wdog_ctr_addr=", wdog_ctr);
384 +EXPORT_SYMBOL(vpe1_wdog_ctr);
385 +
386 +uint32_t vpe1_wdog_timeout;
387 +static int __init wdog_timeout(char *str)
388 +{
389 + get_option(&str, &vpe1_wdog_timeout);
390 + return 1;
391 +}
392 +
393 +__setup("vpe1_wdog_timeout=", wdog_timeout);
394 +EXPORT_SYMBOL(vpe1_wdog_timeout);
395 +
396 +#endif
397 /* grab the likely amount of memory we will need. */
398 #ifdef CONFIG_MIPS_VPE_LOADER_TOM
399 #define P_SIZE (2 * 1024 * 1024)
400 @@ -268,6 +320,13 @@
401 void *addr;
402
403 #ifdef CONFIG_MIPS_VPE_LOADER_TOM
404 +#ifdef CONFIG_IFX_VPE_EXT
405 + if (vpe1_load_addr) {
406 + memset((void *)vpe1_load_addr, 0, len);
407 + return (void *)vpe1_load_addr;
408 + }
409 +#endif
410 +
411 /*
412 * This means you must tell Linux to use less memory than you
413 * physically have, for example by passing a mem= boot argument.
414 @@ -746,6 +805,12 @@
415 }
416
417 /* Write the address we want it to start running from in the TCPC register. */
418 +#if defined(CONFIG_IFX_VPE_EXT) && 0
419 + if (stlb)
420 + write_vpe_c0_wired(vpe0_wired + vpe1_wired);
421 + else
422 + write_vpe_c0_wired(vpe1_wired);
423 +#endif
424 write_tc_c0_tcrestart((unsigned long)v->__start);
425 write_tc_c0_tccontext((unsigned long)0);
426
427 @@ -759,6 +824,20 @@
428
429 write_tc_c0_tchalt(read_tc_c0_tchalt() & ~TCHALT_H);
430
431 +#if defined(CONFIG_IFX_VPE_EXT) && 0
432 + /*
433 + * $a2 & $a3 are used to pass command line parameters to VPE1. $a2
434 + * points to the start of the command line string and $a3 points to
435 + * the end of the string. This convention is identical to the Linux
436 + * kernel boot parameter passing mechanism. Please note that $a3 is
437 + * used to pass physical memory size or 0 in SDE tool kit. So, if you
438 + * are passing comand line parameters through $a2 & $a3 SDE programs
439 + * don't work as desired.
440 + */
441 + mttgpr(6, command_line);
442 + mttgpr(7, (command_line + strlen(command_line)));
443 + if (is_sdepgm)
444 +#endif
445 /*
446 * The sde-kit passes 'memsize' to __start in $a3, so set something
447 * here... Or set $a3 to zero and define DFLT_STACK_SIZE and
448 @@ -833,6 +912,9 @@
449 if ( (v->__start == 0) || (v->shared_ptr == NULL))
450 return -1;
451
452 +#ifdef CONFIG_IFX_VPE_EXT
453 + is_sdepgm = 1;
454 +#endif
455 return 0;
456 }
457
458 @@ -994,6 +1076,15 @@
459 (unsigned long)v->load_addr + v->len);
460
461 if ((find_vpe_symbols(v, sechdrs, symindex, strtab, &mod)) < 0) {
462 +#ifdef CONFIG_IFX_VPE_EXT
463 + if (vpe1_load_addr) {
464 + /* Conversion to KSEG1 is required ??? */
465 + v->__start = KSEG1ADDR(vpe1_load_addr);
466 + is_sdepgm = 0;
467 + return 0;
468 + }
469 +#endif
470 +
471 if (v->__start == 0) {
472 printk(KERN_WARNING "VPE loader: program does not contain "
473 "a __start symbol\n");
474 @@ -1064,6 +1155,9 @@
475 struct vpe_notifications *not;
476 struct vpe *v;
477 int ret;
478 +#ifdef CONFIG_IFX_VPE_EXT
479 + int progsize;
480 +#endif
481
482 if (minor != iminor(inode)) {
483 /* assume only 1 device at the moment. */
484 @@ -1089,7 +1183,12 @@
485 release_progmem(v->load_addr);
486 cleanup_tc(get_tc(tclimit));
487 }
488 -
489 +#ifdef CONFIG_IFX_VPE_EXT
490 + progsize = (vpe1_mem != 0) ? vpe1_mem : P_SIZE;
491 + //printk("progsize = %x\n", progsize);
492 + v->pbuffer = vmalloc(progsize);
493 + v->plen = progsize;
494 +#else
495 /* this of-course trashes what was there before... */
496 v->pbuffer = vmalloc(P_SIZE);
497 if (!v->pbuffer) {
498 @@ -1097,11 +1196,14 @@
499 return -ENOMEM;
500 }
501 v->plen = P_SIZE;
502 +#endif
503 v->load_addr = NULL;
504 v->len = 0;
505
506 +#if 0
507 v->uid = filp->f_cred->fsuid;
508 v->gid = filp->f_cred->fsgid;
509 +#endif
510
511 #ifdef CONFIG_MIPS_APSP_KSPD
512 /* get kspd to tell us when a syscall_exit happens */
513 @@ -1349,6 +1451,133 @@
514 cleanup_tc(get_tc(sp_id));
515 }
516 #endif
517 +#ifdef CONFIG_IFX_VPE_EXT
518 +int32_t vpe1_sw_start(void* sw_start_addr, uint32_t tcmask, uint32_t flags)
519 +{
520 + enum vpe_state state;
521 + struct vpe *v = get_vpe(tclimit);
522 + struct vpe_notifications *not;
523 +
524 + if (tcmask || flags) {
525 + printk(KERN_WARNING "Currently tcmask and flags should be 0.\
526 + other values not supported\n");
527 + return -1;
528 + }
529 +
530 + state = xchg(&v->state, VPE_STATE_INUSE);
531 + if (state != VPE_STATE_UNUSED) {
532 + vpe_stop(v);
533 +
534 + list_for_each_entry(not, &v->notify, list) {
535 + not->stop(tclimit);
536 + }
537 + }
538 +
539 + v->__start = (unsigned long)sw_start_addr;
540 + is_sdepgm = 0;
541 +
542 + if (!vpe_run(v)) {
543 + printk(KERN_DEBUG "VPE loader: VPE1 running successfully\n");
544 + return 0;
545 + }
546 + return -1;
547 +}
548 +
549 +EXPORT_SYMBOL(vpe1_sw_start);
550 +
551 +int32_t vpe1_sw_stop(uint32_t flags)
552 +{
553 + struct vpe *v = get_vpe(tclimit);
554 +
555 + if (!vpe_free(v)) {
556 + printk(KERN_DEBUG "RP Stopped\n");
557 + return 0;
558 + }
559 + else
560 + return -1;
561 +}
562 +
563 +EXPORT_SYMBOL(vpe1_sw_stop);
564 +
565 +uint32_t vpe1_get_load_addr (uint32_t flags)
566 +{
567 + return vpe1_load_addr;
568 +}
569 +
570 +EXPORT_SYMBOL(vpe1_get_load_addr);
571 +
572 +uint32_t vpe1_get_max_mem (uint32_t flags)
573 +{
574 + if (!vpe1_mem)
575 + return P_SIZE;
576 + else
577 + return vpe1_mem;
578 +}
579 +
580 +EXPORT_SYMBOL(vpe1_get_max_mem);
581 +
582 +void* vpe1_get_cmdline_argument(void)
583 +{
584 + return saved_command_line;
585 +}
586 +
587 +EXPORT_SYMBOL(vpe1_get_cmdline_argument);
588 +
589 +int32_t vpe1_set_boot_param(char *field, char *value, char flags)
590 +{
591 + char *ptr, string[64];
592 + int start_off, end_off;
593 + if (!field)
594 + return -1;
595 + strcpy(string, field);
596 + if (value) {
597 + strcat(string, "=");
598 + strcat(string, value);
599 + strcat(command_line, " ");
600 + strcat(command_line, string);
601 + }
602 + else {
603 + ptr = strstr(command_line, string);
604 + if (ptr) {
605 + start_off = ptr - command_line;
606 + ptr += strlen(string);
607 + while ((*ptr != ' ') && (*ptr != '\0'))
608 + ptr++;
609 + end_off = ptr - command_line;
610 + command_line[start_off] = '\0';
611 + strcat (command_line, command_line+end_off);
612 + }
613 + }
614 + return 0;
615 +}
616 +
617 +EXPORT_SYMBOL(vpe1_set_boot_param);
618 +
619 +int32_t vpe1_get_boot_param(char *field, char **value, char flags)
620 +{
621 + char *ptr, string[64];
622 + int i = 0;
623 + if (!field)
624 + return -1;
625 + if ((ptr = strstr(command_line, field))) {
626 + ptr += strlen(field) + 1; /* including = */
627 + while ((*ptr != ' ') && (*ptr != '\0'))
628 + string[i++] = *ptr++;
629 + string[i] = '\0';
630 + *value = kmalloc((strlen(string) + 1), GFP_KERNEL);
631 + if (*value != NULL)
632 + strcpy(*value, string);
633 + }
634 + else
635 + *value = NULL;
636 +
637 + return 0;
638 +}
639 +
640 +EXPORT_SYMBOL(vpe1_get_boot_param);
641 +
642 +extern void configure_tlb(void);
643 +#endif
644
645 static ssize_t store_kill(struct device *dev, struct device_attribute *attr,
646 const char *buf, size_t len)
647 @@ -1430,6 +1659,18 @@
648 printk("VPE loader: not a MIPS MT capable processor\n");
649 return -ENODEV;
650 }
651 +#ifdef CONFIG_IFX_VPE_EXT
652 +#ifndef CONFIG_MIPS_MT_SMTC
653 + configure_tlb();
654 +#endif
655 +#endif
656 +
657 +#ifndef CONFIG_MIPS_MT_SMTC
658 + if (!vpelimit)
659 + vpelimit = 1;
660 + if (!tclimit)
661 + tclimit = 1;
662 +#endif
663
664 if (vpelimit == 0) {
665 printk(KERN_WARNING "No VPEs reserved for AP/SP, not "
666 @@ -1474,10 +1715,12 @@
667 mtflags = dmt();
668 vpflags = dvpe();
669
670 + back_to_back_c0_hazard();
671 +
672 /* Put MVPE's into 'configuration state' */
673 set_c0_mvpcontrol(MVPCONTROL_VPC);
674
675 - /* dump_mtregs(); */
676 + dump_mtregs();
677
678 val = read_c0_mvpconf0();
679 hw_tcs = (val & MVPCONF0_PTC) + 1;
680 @@ -1489,6 +1732,7 @@
681 * reschedule send IPIs or similar we might hang.
682 */
683 clear_c0_mvpcontrol(MVPCONTROL_VPC);
684 + back_to_back_c0_hazard();
685 evpe(vpflags);
686 emt(mtflags);
687 local_irq_restore(flags);
688 @@ -1514,6 +1758,7 @@
689 }
690
691 v->ntcs = hw_tcs - tclimit;
692 + write_tc_c0_tcbind((read_tc_c0_tcbind() & ~TCBIND_CURVPE) | 1);
693
694 /* add the tc to the list of this vpe's tc's. */
695 list_add(&t->tc, &v->tc);
696 @@ -1582,6 +1827,7 @@
697 out_reenable:
698 /* release config state */
699 clear_c0_mvpcontrol(MVPCONTROL_VPC);
700 + back_to_back_c0_hazard();
701
702 evpe(vpflags);
703 emt(mtflags);
704 --- /dev/null
705 +++ b/arch/mips/kernel/mtsched_proc.c
706 @@ -0,0 +1,279 @@
707 +/*
708 + * /proc hooks for MIPS MT scheduling policy management for 34K cores
709 + *
710 + * This program is free software; you can distribute it and/or modify it
711 + * under the terms of the GNU General Public License (Version 2) as
712 + * published by the Free Software Foundation.
713 + *
714 + * This program is distributed in the hope it will be useful, but WITHOUT
715 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
716 + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
717 + * for more details.
718 + *
719 + * You should have received a copy of the GNU General Public License along
720 + * with this program; if not, write to the Free Software Foundation, Inc.,
721 + * 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
722 + *
723 + * Copyright (C) 2006 Mips Technologies, Inc
724 + */
725 +
726 +#include <linux/kernel.h>
727 +
728 +#include <asm/cpu.h>
729 +#include <asm/processor.h>
730 +#include <asm/system.h>
731 +#include <asm/mipsregs.h>
732 +#include <asm/mipsmtregs.h>
733 +#include <asm/uaccess.h>
734 +#include <linux/proc_fs.h>
735 +
736 +static struct proc_dir_entry *mtsched_proc;
737 +
738 +#ifndef CONFIG_MIPS_MT_SMTC
739 +#define NTCS 2
740 +#else
741 +#define NTCS NR_CPUS
742 +#endif
743 +#define NVPES 2
744 +
745 +int lastvpe = 1;
746 +int lasttc = 8;
747 +
748 +static int proc_read_mtsched(char *page, char **start, off_t off,
749 + int count, int *eof, void *data)
750 +{
751 + int totalen = 0;
752 + int len;
753 +
754 + int i;
755 + int vpe;
756 + int mytc;
757 + unsigned long flags;
758 + unsigned int mtflags;
759 + unsigned int haltstate;
760 + unsigned int vpes_checked[NVPES];
761 + unsigned int vpeschedule[NVPES];
762 + unsigned int vpeschefback[NVPES];
763 + unsigned int tcschedule[NTCS];
764 + unsigned int tcschefback[NTCS];
765 +
766 + /* Dump the state of the MIPS MT scheduling policy manager */
767 + /* Inititalize control state */
768 + for(i = 0; i < NVPES; i++) {
769 + vpes_checked[i] = 0;
770 + vpeschedule[i] = 0;
771 + vpeschefback[i] = 0;
772 + }
773 + for(i = 0; i < NTCS; i++) {
774 + tcschedule[i] = 0;
775 + tcschefback[i] = 0;
776 + }
777 +
778 + /* Disable interrupts and multithreaded issue */
779 + local_irq_save(flags);
780 + mtflags = dvpe();
781 +
782 + /* Then go through the TCs, halt 'em, and extract the values */
783 + mytc = (read_c0_tcbind() & TCBIND_CURTC) >> TCBIND_CURTC_SHIFT;
784 + for(i = 0; i < NTCS; i++) {
785 + if(i == mytc) {
786 + /* No need to halt ourselves! */
787 + tcschedule[i] = read_c0_tcschedule();
788 + tcschefback[i] = read_c0_tcschefback();
789 + /* If VPE bound to TC hasn't been checked, do it */
790 + vpe = read_c0_tcbind() & TCBIND_CURVPE;
791 + if(!vpes_checked[vpe]) {
792 + vpeschedule[vpe] = read_c0_vpeschedule();
793 + vpeschefback[vpe] = read_c0_vpeschefback();
794 + vpes_checked[vpe] = 1;
795 + }
796 + } else {
797 + settc(i);
798 + haltstate = read_tc_c0_tchalt();
799 + write_tc_c0_tchalt(TCHALT_H);
800 + mips_ihb();
801 + tcschedule[i] = read_tc_c0_tcschedule();
802 + tcschefback[i] = read_tc_c0_tcschefback();
803 + /* If VPE bound to TC hasn't been checked, do it */
804 + vpe = read_tc_c0_tcbind() & TCBIND_CURVPE;
805 + if(!vpes_checked[vpe]) {
806 + vpeschedule[vpe] = read_vpe_c0_vpeschedule();
807 + vpeschefback[vpe] = read_vpe_c0_vpeschefback();
808 + vpes_checked[vpe] = 1;
809 + }
810 + if(!haltstate) write_tc_c0_tchalt(0);
811 + }
812 + }
813 + /* Re-enable MT and interrupts */
814 + evpe(mtflags);
815 + local_irq_restore(flags);
816 +
817 + for(vpe=0; vpe < NVPES; vpe++) {
818 + len = sprintf(page, "VPE[%d].VPEschedule = 0x%08x\n",
819 + vpe, vpeschedule[vpe]);
820 + totalen += len;
821 + page += len;
822 + len = sprintf(page, "VPE[%d].VPEschefback = 0x%08x\n",
823 + vpe, vpeschefback[vpe]);
824 + totalen += len;
825 + page += len;
826 + }
827 + for(i=0; i < NTCS; i++) {
828 + len = sprintf(page, "TC[%d].TCschedule = 0x%08x\n",
829 + i, tcschedule[i]);
830 + totalen += len;
831 + page += len;
832 + len = sprintf(page, "TC[%d].TCschefback = 0x%08x\n",
833 + i, tcschefback[i]);
834 + totalen += len;
835 + page += len;
836 + }
837 + return totalen;
838 +}
839 +
840 +/*
841 + * Write to perf counter registers based on text input
842 + */
843 +
844 +#define TXTBUFSZ 100
845 +
846 +static int proc_write_mtsched(struct file *file, const char *buffer,
847 + unsigned long count, void *data)
848 +{
849 + int len = 0;
850 + char mybuf[TXTBUFSZ];
851 + /* At most, we will set up 9 TCs and 2 VPEs, 11 entries in all */
852 + char entity[1]; //, entity1[1];
853 + int number[1];
854 + unsigned long value[1];
855 + int nparsed = 0 , index = 0;
856 + unsigned long flags;
857 + unsigned int mtflags;
858 + unsigned int haltstate;
859 + unsigned int tcbindval;
860 +
861 + if(count >= TXTBUFSZ) len = TXTBUFSZ-1;
862 + else len = count;
863 + memset(mybuf,0,TXTBUFSZ);
864 + if(copy_from_user(mybuf, buffer, len)) return -EFAULT;
865 +
866 + nparsed = sscanf(mybuf, "%c%d %lx",
867 + &entity[0] ,&number[0], &value[0]);
868 +
869 + /*
870 + * Having acquired the inputs, which might have
871 + * generated exceptions and preemptions,
872 + * program the registers.
873 + */
874 + /* Disable interrupts and multithreaded issue */
875 + local_irq_save(flags);
876 + mtflags = dvpe();
877 +
878 + if(entity[index] == 't' ) {
879 + /* Set TCSchedule or TCScheFBack of specified TC */
880 + if(number[index] > NTCS) goto skip;
881 + /* If it's our own TC, do it direct */
882 + if(number[index] ==
883 + ((read_c0_tcbind() & TCBIND_CURTC)
884 + >> TCBIND_CURTC_SHIFT)) {
885 + if(entity[index] == 't')
886 + write_c0_tcschedule(value[index]);
887 + else
888 + write_c0_tcschefback(value[index]);
889 + } else {
890 + /* Otherwise, we do it via MTTR */
891 + settc(number[index]);
892 + haltstate = read_tc_c0_tchalt();
893 + write_tc_c0_tchalt(TCHALT_H);
894 + mips_ihb();
895 + if(entity[index] == 't')
896 + write_tc_c0_tcschedule(value[index]);
897 + else
898 + write_tc_c0_tcschefback(value[index]);
899 + mips_ihb();
900 + if(!haltstate) write_tc_c0_tchalt(0);
901 + }
902 + } else if(entity[index] == 'v') {
903 + /* Set VPESchedule of specified VPE */
904 + if(number[index] > NVPES) goto skip;
905 + tcbindval = read_c0_tcbind();
906 + /* Are we doing this to our current VPE? */
907 + if((tcbindval & TCBIND_CURVPE) == number[index]) {
908 + /* Then life is simple */
909 + write_c0_vpeschedule(value[index]);
910 + } else {
911 + /*
912 + * Bind ourselves to the other VPE long enough
913 + * to program the bind value.
914 + */
915 + write_c0_tcbind((tcbindval & ~TCBIND_CURVPE)
916 + | number[index]);
917 + mips_ihb();
918 + write_c0_vpeschedule(value[index]);
919 + mips_ihb();
920 + /* Restore previous binding */
921 + write_c0_tcbind(tcbindval);
922 + mips_ihb();
923 + }
924 + }
925 +
926 + else if(entity[index] == 'r') {
927 + unsigned int vpes_checked[2], vpe ,i , mytc;
928 + vpes_checked[0] = vpes_checked[1] = 0;
929 +
930 + /* Then go through the TCs, halt 'em, and extract the values */
931 + mytc = (read_c0_tcbind() & TCBIND_CURTC) >> TCBIND_CURTC_SHIFT;
932 +
933 + for(i = 0; i < NTCS; i++) {
934 + if(i == mytc) {
935 + /* No need to halt ourselves! */
936 + write_c0_vpeschefback(0);
937 + write_c0_tcschefback(0);
938 + } else {
939 + settc(i);
940 + haltstate = read_tc_c0_tchalt();
941 + write_tc_c0_tchalt(TCHALT_H);
942 + mips_ihb();
943 + write_tc_c0_tcschefback(0);
944 + /* If VPE bound to TC hasn't been checked, do it */
945 + vpe = read_tc_c0_tcbind() & TCBIND_CURVPE;
946 + if(!vpes_checked[vpe]) {
947 + write_vpe_c0_vpeschefback(0);
948 + vpes_checked[vpe] = 1;
949 + }
950 + if(!haltstate) write_tc_c0_tchalt(0);
951 + }
952 + }
953 + }
954 + else {
955 + printk ("\n Usage : <t/v><0/1> <Hex Value>\n Example : t0 0x01\n");
956 + }
957 +
958 +skip:
959 + /* Re-enable MT and interrupts */
960 + evpe(mtflags);
961 + local_irq_restore(flags);
962 + return (len);
963 +}
964 +
965 +static int __init init_mtsched_proc(void)
966 +{
967 + extern struct proc_dir_entry *get_mips_proc_dir(void);
968 + struct proc_dir_entry *mips_proc_dir;
969 +
970 + if (!cpu_has_mipsmt) {
971 + printk("mtsched: not a MIPS MT capable processor\n");
972 + return -ENODEV;
973 + }
974 +
975 + mips_proc_dir = get_mips_proc_dir();
976 +
977 + mtsched_proc = create_proc_entry("mtsched", 0644, mips_proc_dir);
978 + mtsched_proc->read_proc = proc_read_mtsched;
979 + mtsched_proc->write_proc = proc_write_mtsched;
980 +
981 + return 0;
982 +}
983 +
984 +/* Automagically create the entry */
985 +module_init(init_mtsched_proc);
986 --- /dev/null
987 +++ b/arch/mips/kernel/perf_proc.c
988 @@ -0,0 +1,191 @@
989 +/*
990 + * /proc hooks for CPU performance counter support for SMTC kernel
991 + * (and ultimately others)
992 + * Copyright (C) 2006 Mips Technologies, Inc
993 + */
994 +
995 +#include <linux/kernel.h>
996 +
997 +#include <asm/cpu.h>
998 +#include <asm/processor.h>
999 +#include <asm/system.h>
1000 +#include <asm/mipsregs.h>
1001 +#include <asm/uaccess.h>
1002 +#include <linux/proc_fs.h>
1003 +
1004 +/*
1005 + * /proc diagnostic and statistics hooks
1006 + */
1007 +
1008 +
1009 +/* Internal software-extended event counters */
1010 +
1011 +static unsigned long long extencount[4] = {0,0,0,0};
1012 +
1013 +static struct proc_dir_entry *perf_proc;
1014 +
1015 +static int proc_read_perf(char *page, char **start, off_t off,
1016 + int count, int *eof, void *data)
1017 +{
1018 + int totalen = 0;
1019 + int len;
1020 +
1021 + len = sprintf(page, "PerfCnt[0].Ctl : 0x%08x\n", read_c0_perfctrl0());
1022 + totalen += len;
1023 + page += len;
1024 + len = sprintf(page, "PerfCnt[0].Cnt : %Lu\n",
1025 + extencount[0] + (unsigned long long)((unsigned)read_c0_perfcntr0()));
1026 + totalen += len;
1027 + page += len;
1028 + len = sprintf(page, "PerfCnt[1].Ctl : 0x%08x\n", read_c0_perfctrl1());
1029 + totalen += len;
1030 + page += len;
1031 + len = sprintf(page, "PerfCnt[1].Cnt : %Lu\n",
1032 + extencount[1] + (unsigned long long)((unsigned)read_c0_perfcntr1()));
1033 + totalen += len;
1034 + page += len;
1035 + len = sprintf(page, "PerfCnt[2].Ctl : 0x%08x\n", read_c0_perfctrl2());
1036 + totalen += len;
1037 + page += len;
1038 + len = sprintf(page, "PerfCnt[2].Cnt : %Lu\n",
1039 + extencount[2] + (unsigned long long)((unsigned)read_c0_perfcntr2()));
1040 + totalen += len;
1041 + page += len;
1042 + len = sprintf(page, "PerfCnt[3].Ctl : 0x%08x\n", read_c0_perfctrl3());
1043 + totalen += len;
1044 + page += len;
1045 + len = sprintf(page, "PerfCnt[3].Cnt : %Lu\n",
1046 + extencount[3] + (unsigned long long)((unsigned)read_c0_perfcntr3()));
1047 + totalen += len;
1048 + page += len;
1049 +
1050 + return totalen;
1051 +}
1052 +
1053 +/*
1054 + * Write to perf counter registers based on text input
1055 + */
1056 +
1057 +#define TXTBUFSZ 100
1058 +
1059 +static int proc_write_perf(struct file *file, const char *buffer,
1060 + unsigned long count, void *data)
1061 +{
1062 + int len;
1063 + int nparsed;
1064 + int index;
1065 + char mybuf[TXTBUFSZ];
1066 +
1067 + int which[4];
1068 + unsigned long control[4];
1069 + long long ctrdata[4];
1070 +
1071 + if(count >= TXTBUFSZ) len = TXTBUFSZ-1;
1072 + else len = count;
1073 + memset(mybuf,0,TXTBUFSZ);
1074 + if(copy_from_user(mybuf, buffer, len)) return -EFAULT;
1075 +
1076 + nparsed = sscanf(mybuf,
1077 + "%d %lx %Ld %d %lx %Ld %d %lx %Ld %d %lx %Ld",
1078 + &which[0], &control[0], &ctrdata[0],
1079 + &which[1], &control[1], &ctrdata[1],
1080 + &which[2], &control[2], &ctrdata[2],
1081 + &which[3], &control[3], &ctrdata[3]);
1082 +
1083 + for(index = 0; nparsed >= 3; index++) {
1084 + switch (which[index]) {
1085 + case 0:
1086 + write_c0_perfctrl0(control[index]);
1087 + if(ctrdata[index] != -1) {
1088 + extencount[0] = (unsigned long long)ctrdata[index];
1089 + write_c0_perfcntr0((unsigned long)0);
1090 + }
1091 + break;
1092 + case 1:
1093 + write_c0_perfctrl1(control[index]);
1094 + if(ctrdata[index] != -1) {
1095 + extencount[1] = (unsigned long long)ctrdata[index];
1096 + write_c0_perfcntr1((unsigned long)0);
1097 + }
1098 + break;
1099 + case 2:
1100 + write_c0_perfctrl2(control[index]);
1101 + if(ctrdata[index] != -1) {
1102 + extencount[2] = (unsigned long long)ctrdata[index];
1103 + write_c0_perfcntr2((unsigned long)0);
1104 + }
1105 + break;
1106 + case 3:
1107 + write_c0_perfctrl3(control[index]);
1108 + if(ctrdata[index] != -1) {
1109 + extencount[3] = (unsigned long long)ctrdata[index];
1110 + write_c0_perfcntr3((unsigned long)0);
1111 + }
1112 + break;
1113 + }
1114 + nparsed -= 3;
1115 + }
1116 + return (len);
1117 +}
1118 +
1119 +extern int (*perf_irq)(void);
1120 +
1121 +/*
1122 + * Invoked when timer interrupt vector picks up a perf counter overflow
1123 + */
1124 +
1125 +static int perf_proc_irq(void)
1126 +{
1127 + unsigned long snapshot;
1128 +
1129 + /*
1130 + * It would be nice to do this as a loop, but we don't have
1131 + * indirect access to CP0 registers.
1132 + */
1133 + snapshot = read_c0_perfcntr0();
1134 + if ((long)snapshot < 0) {
1135 + extencount[0] +=
1136 + (unsigned long long)((unsigned)read_c0_perfcntr0());
1137 + write_c0_perfcntr0(0);
1138 + }
1139 + snapshot = read_c0_perfcntr1();
1140 + if ((long)snapshot < 0) {
1141 + extencount[1] +=
1142 + (unsigned long long)((unsigned)read_c0_perfcntr1());
1143 + write_c0_perfcntr1(0);
1144 + }
1145 + snapshot = read_c0_perfcntr2();
1146 + if ((long)snapshot < 0) {
1147 + extencount[2] +=
1148 + (unsigned long long)((unsigned)read_c0_perfcntr2());
1149 + write_c0_perfcntr2(0);
1150 + }
1151 + snapshot = read_c0_perfcntr3();
1152 + if ((long)snapshot < 0) {
1153 + extencount[3] +=
1154 + (unsigned long long)((unsigned)read_c0_perfcntr3());
1155 + write_c0_perfcntr3(0);
1156 + }
1157 + return 0;
1158 +}
1159 +
1160 +static int __init init_perf_proc(void)
1161 +{
1162 + extern struct proc_dir_entry *get_mips_proc_dir(void);
1163 +
1164 + struct proc_dir_entry *mips_proc_dir = get_mips_proc_dir();
1165 +
1166 + write_c0_perfcntr0(0);
1167 + write_c0_perfcntr1(0);
1168 + write_c0_perfcntr2(0);
1169 + write_c0_perfcntr3(0);
1170 + perf_proc = create_proc_entry("perf", 0644, mips_proc_dir);
1171 + perf_proc->read_proc = proc_read_perf;
1172 + perf_proc->write_proc = proc_write_perf;
1173 + perf_irq = perf_proc_irq;
1174 +
1175 + return 0;
1176 +}
1177 +
1178 +/* Automagically create the entry */
1179 +module_init(init_perf_proc);
OpenWrt SVN history