OpenWrt – Blame information for rev 4

Subversion Repositories:
Rev:
Rev Author Line No. Line
4 office 1 /******************************************************************************
2 **
3 ** FILE NAME : ifxmips_ptm_vdsl.c
4 ** PROJECT : UEIP
5 ** MODULES : PTM
6 **
7 ** DATE : 7 Jul 2009
8 ** AUTHOR : Xu Liang
9 ** DESCRIPTION : PTM driver common source file (core functions for VR9)
10 ** COPYRIGHT : Copyright (c) 2006
11 ** Infineon Technologies AG
12 ** Am Campeon 1-12, 85579 Neubiberg, Germany
13 **
14 ** This program is free software; you can redistribute it and/or modify
15 ** it under the terms of the GNU General Public License as published by
16 ** the Free Software Foundation; either version 2 of the License, or
17 ** (at your option) any later version.
18 **
19 ** HISTORY
20 ** $Date $Author $Comment
21 ** 07 JUL 2009 Xu Liang Init Version
22 *******************************************************************************/
23  
24  
25  
26 #ifdef CONFIG_IFX_PTM_TEST_PROC
27  
28 /*
29 * ####################################
30 * Head File
31 * ####################################
32 */
33  
34 /*
35 * Common Head File
36 */
37 #include <linux/kernel.h>
38 #include <linux/module.h>
39 #include <linux/version.h>
40 #include <linux/types.h>
41 #include <linux/errno.h>
42 #include <linux/proc_fs.h>
43 #include <linux/init.h>
44 #include <linux/ioctl.h>
45 #include <linux/etherdevice.h>
46  
47 /*
48 * Chip Specific Head File
49 */
50 #include <asm/ifx/ifx_types.h>
51 #include <asm/ifx/ifx_regs.h>
52 #include <asm/ifx/common_routines.h>
53 #include "ifxmips_ptm_common.h"
54 #include "ifxmips_ptm_ppe_common.h"
55  
56  
57  
58 /*
59 * ####################################
60 * Definition
61 * ####################################
62 */
63  
64  
65  
66 /*
67 * ####################################
68 * Declaration
69 * ####################################
70 */
71  
72 /*
73 * Proc File Functions
74 */
75 static inline void proc_file_create(void);
76 static inline void proc_file_delete(void);
77  
78 /*
79 * Proc Help Functions
80 */
81 static int proc_write_mem(struct file *, const char *, unsigned long, void *);
82 static int proc_read_pp32(char *, char **, off_t, int, int *, void *);
83 static int proc_write_pp32(struct file *, const char *, unsigned long, void *);
84 static int stricmp(const char *, const char *);
85 static int strincmp(const char *, const char *, int);
86 static int get_token(char **, char **, int *, int *);
87 static int get_number(char **, int *, int);
88 static inline void ignore_space(char **, int *);
89  
90  
91  
92 /*
93 * ####################################
94 * Local Variable
95 * ####################################
96 */
97  
98  
99  
100 /*
101 * ####################################
102 * Local Function
103 * ####################################
104 */
105  
106 static inline void proc_file_create(void)
107 {
108 struct proc_dir_entry *res;
109  
110 res = create_proc_entry("driver/ifx_ptm/mem",
111 0,
112 NULL);
113 if ( res != NULL )
114 res->write_proc = proc_write_mem;
115 else
116 printk("%s:%s:%d: failed to create proc mem!", __FILE__, __func__, __LINE__);
117  
118 res = create_proc_entry("driver/ifx_ptm/pp32",
119 0,
120 NULL);
121 if ( res != NULL ) {
122 res->read_proc = proc_read_pp32;
123 res->write_proc = proc_write_pp32;
124 }
125 else
126 printk("%s:%s:%d: failed to create proc pp32!", __FILE__, __func__, __LINE__);
127 }
128  
129 static inline void proc_file_delete(void)
130 {
131 remove_proc_entry("driver/ifx_ptm/pp32", NULL);
132  
133 remove_proc_entry("driver/ifx_ptm/mem", NULL);
134 }
135  
136 static inline unsigned long sb_addr_to_fpi_addr_convert(unsigned long sb_addr)
137 {
138 #define PP32_SB_ADDR_END 0xFFFF
139  
140 if ( sb_addr < PP32_SB_ADDR_END) {
141 return (unsigned long ) SB_BUFFER(sb_addr);
142 }
143 else {
144 return sb_addr;
145 }
146 }
147  
148 static int proc_write_mem(struct file *file, const char *buf, unsigned long count, void *data)
149 {
150 char *p1, *p2;
151 int len;
152 int colon;
153 unsigned long *p;
154 char local_buf[1024];
155 int i, n, l;
156  
157 len = sizeof(local_buf) < count ? sizeof(local_buf) - 1 : count;
158 len = len - copy_from_user(local_buf, buf, len);
159 local_buf[len] = 0;
160  
161 p1 = local_buf;
162 colon = 1;
163 while ( get_token(&p1, &p2, &len, &colon) )
164 {
165 if ( stricmp(p1, "w") == 0 || stricmp(p1, "write") == 0 || stricmp(p1, "r") == 0 || stricmp(p1, "read") == 0 )
166 break;
167  
168 p1 = p2;
169 colon = 1;
170 }
171  
172 if ( *p1 == 'w' )
173 {
174 ignore_space(&p2, &len);
175 p = (unsigned long *)get_number(&p2, &len, 1);
176 p = (unsigned long *)sb_addr_to_fpi_addr_convert( (unsigned long) p);
177  
178 if ( (u32)p >= KSEG0 )
179 while ( 1 )
180 {
181 ignore_space(&p2, &len);
182 if ( !len || !((*p2 >= '0' && *p2 <= '9') || (*p2 >= 'a' && *p2 <= 'f') || (*p2 >= 'A' && *p2 <= 'F')) )
183 break;
184  
185 *p++ = (u32)get_number(&p2, &len, 1);
186 }
187 }
188 else if ( *p1 == 'r' )
189 {
190 ignore_space(&p2, &len);
191 p = (unsigned long *)get_number(&p2, &len, 1);
192 p = (unsigned long *)sb_addr_to_fpi_addr_convert( (unsigned long) p);
193  
194 if ( (u32)p >= KSEG0 )
195 {
196 ignore_space(&p2, &len);
197 n = (int)get_number(&p2, &len, 0);
198 if ( n )
199 {
200 char str[32] = {0};
201 char *pch = str;
202 int k;
203 u32 data;
204 char c;
205  
206 n += (l = ((int)p >> 2) & 0x03);
207 p = (unsigned long *)((u32)p & ~0x0F);
208 for ( i = 0; i < n; i++ )
209 {
210 if ( (i & 0x03) == 0 )
211 {
212 printk("%08X:", (u32)p);
213 pch = str;
214 }
215 if ( i < l )
216 {
217 printk(" ");
218 sprintf(pch, " ");
219 }
220 else
221 {
222 data = (u32)*p;
223 printk(" %08X", data);
224 for ( k = 0; k < 4; k++ )
225 {
226 c = ((char*)&data)[k];
227 pch[k] = c < ' ' ? '.' : c;
228 }
229 }
230 p++;
231 pch += 4;
232 if ( (i & 0x03) == 0x03 )
233 {
234 pch[0] = 0;
235 printk(" ; %s\n", str);
236 }
237 }
238 if ( (n & 0x03) != 0x00 )
239 {
240 for ( k = 4 - (n & 0x03); k > 0; k-- )
241 printk(" ");
242 pch[0] = 0;
243 printk(" ; %s\n", str);
244 }
245 }
246 }
247 }
248  
249 return count;
250 }
251  
252 #ifdef CONFIG_DANUBE
253  
254 static int proc_read_pp32(char *page, char **start, off_t off, int count, int *eof, void *data)
255 {
256 static const char *halt_stat[] = {
257 "reset",
258 "break in line",
259 "stop",
260 "step",
261 "code",
262 "data0",
263 "data1"
264 };
265 static const char *brk_src_data[] = {
266 "off",
267 "read",
268 "write",
269 "read/write",
270 "write_equal",
271 "N/A",
272 "N/A",
273 "N/A"
274 };
275 static const char *brk_src_code[] = {
276 "off",
277 "on"
278 };
279  
280 int len = 0;
281 int cur_task;
282 int i, j;
283 int k;
284 unsigned long bit;
285  
286 len += sprintf(page + off + len, "Task No %d, PC %04x\n", *PP32_DBG_TASK_NO & 0x03, *PP32_DBG_CUR_PC & 0xFFFF);
287  
288 if ( !(*PP32_HALT_STAT & 0x01) )
289 len += sprintf(page + off + len, " Halt State: Running\n");
290 else
291 {
292 len += sprintf(page + off + len, " Halt State: Stopped");
293 k = 0;
294 for ( bit = 2, i = 0; bit <= (1 << 7); bit <<= 1, i++ )
295 if ( (*PP32_HALT_STAT & bit) )
296 {
297 if ( !k )
298 {
299 len += sprintf(page + off + len, ", ");
300 k++;
301 }
302 else
303 len += sprintf(page + off + len, " | ");
304 len += sprintf(page + off + len, halt_stat[i]);
305 }
306  
307 len += sprintf(page + off + len, "\n");
308  
309 cur_task = *PP32_DBG_TASK_NO & 0x03;
310 len += sprintf(page + off + len, "General Purpose Register (Task %d):\n", cur_task);
311 for ( i = 0; i < 4; i++ )
312 {
313 for ( j = 0; j < 4; j++ )
314 len += sprintf(page + off + len, " %2d: %08x", i + j * 4, *PP32_DBG_TASK_GPR(cur_task, i + j * 4));
315 len += sprintf(page + off + len, "\n");
316 }
317 }
318  
319 len += sprintf(page + off + len, " Break Src: data1 - %s, data0 - %s, pc3 - %s, pc2 - %s, pc1 - %s, pc0 - %s\n",
320 brk_src_data[(*PP32_BRK_SRC >> 11) & 0x07], brk_src_data[(*PP32_BRK_SRC >> 8) & 0x07], brk_src_code[(*PP32_BRK_SRC >> 3) & 0x01], brk_src_code[(*PP32_BRK_SRC >> 2) & 0x01], brk_src_code[(*PP32_BRK_SRC >> 1) & 0x01], brk_src_code[*PP32_BRK_SRC & 0x01]);
321  
322 for ( i = 0; i < 4; i++ )
323 len += sprintf(page + off + len, " pc%d: %04x - %04x\n", i, *PP32_DBG_PC_MIN(i), *PP32_DBG_PC_MAX(i));
324  
325 for ( i = 0; i < 2; i++ )
326 len += sprintf(page + off + len, " data%d: %04x - %04x (%08x)\n", i, *PP32_DBG_DATA_MIN(i), *PP32_DBG_DATA_MAX(i), *PP32_DBG_DATA_VAL(i));
327  
328 *eof = 1;
329  
330 return len;
331 }
332  
333 static int proc_write_pp32(struct file *file, const char *buf, unsigned long count, void *data)
334 {
335 char str[2048];
336 char *p;
337 int len, rlen;
338  
339 int id;
340 u32 addr;
341 u32 cmd;
342  
343 len = count < sizeof(str) ? count : sizeof(str) - 1;
344 rlen = len - copy_from_user(str, buf, len);
345 while ( rlen && str[rlen - 1] <= ' ' )
346 rlen--;
347 str[rlen] = 0;
348 for ( p = str; *p && *p <= ' '; p++, rlen-- );
349 if ( !*p )
350 {
351 return 0;
352 }
353  
354 if ( stricmp(str, "start") == 0 )
355 *PP32_DBG_CTRL = DBG_CTRL_START_SET(1);
356 else if ( stricmp(str, "stop") == 0 )
357 *PP32_DBG_CTRL = DBG_CTRL_STOP_SET(1);
358 else if ( stricmp(str, "step") == 0 )
359 *PP32_DBG_CTRL = DBG_CTRL_STEP_SET(1);
360 else if ( strincmp(p, "pc", 2) == 0 && p[2] >= '0' && p[2] <= '3' && p[3] == ' ' )
361 {
362 id = (int)(p[2] - '0');
363 p += 4;
364 rlen -= 4;
365 *PP32_BRK_SRC &= ~PP32_BRK_SRC_PC(id);
366 if ( stricmp(p, "off") != 0 )
367 {
368 ignore_space(&p, &rlen);
369 *PP32_DBG_PC_MIN(id) = *PP32_DBG_PC_MAX(id) = get_number(&p, &rlen, 1);
370 ignore_space(&p, &rlen);
371 if ( rlen > 0 )
372 {
373 addr = get_number(&p, &rlen, 1);
374 if ( addr >= *PP32_DBG_PC_MIN(id) )
375 *PP32_DBG_PC_MAX(id) = addr;
376 else
377 *PP32_DBG_PC_MIN(id) = addr;
378 }
379 *PP32_BRK_SRC |= PP32_BRK_SRC_PC(id);
380 }
381 }
382 else if ( strincmp(p, "daddr", 5) == 0 && p[5] >= '0' && p[5] <= '1' && p[6] == ' ' )
383 {
384 id = (int)(p[5] - '0');
385 p += 7;
386 rlen -= 7;
387 *PP32_BRK_SRC &= ~PP32_BRK_SRC_DATA(id, 7);
388 if ( stricmp(p, "off") != 0 )
389 {
390 ignore_space(&p, &rlen);
391 *PP32_DBG_DATA_MIN(id) = *PP32_DBG_DATA_MAX(id) = get_number(&p, &rlen, 1);
392 cmd = 1;
393 ignore_space(&p, &rlen);
394 if ( rlen > 0 && ((*p >= '0' && *p <= '9') || (*p >= 'a' && *p <= 'f') || (*p >= 'A' && *p <= 'F')) )
395 {
396 addr = get_number(&p, &rlen, 1);
397 if ( addr >= *PP32_DBG_PC_MIN(id) )
398 *PP32_DBG_DATA_MAX(id) = addr;
399 else
400 *PP32_DBG_DATA_MIN(id) = addr;
401 ignore_space(&p, &rlen);
402 }
403 if ( *p == 'w' )
404 cmd = 2;
405 else if ( *p == 'r' && p[1] == 'w' )
406 {
407 cmd = 3;
408 p++;
409 rlen--;
410 }
411 p++;
412 rlen--;
413 if ( rlen > 0 )
414 {
415 ignore_space(&p, &rlen);
416 if ( (*p >= '0' && *p <= '9') || (*p >= 'a' && *p <= 'f') || (*p >= 'A' && *p <= 'F'))
417 {
418 *PP32_DBG_DATA_VAL(id) = get_number(&p, &rlen, 1);
419 cmd = 4;
420 }
421 }
422 *PP32_BRK_SRC |= PP32_BRK_SRC_DATA(id, cmd);
423 }
424 }
425 else
426 {
427 printk("echo \"<command>\" > /proc/driver/ifx_ptm/pp32\n");
428 printk(" command:\n");
429 printk(" start - run pp32\n");
430 printk(" stop - stop pp32\n");
431 printk(" step - run pp32 with one step only\n");
432 printk(" pc0 - pc0 <addr_min [addr_max]>/off, set break point PC0\n");
433 printk(" pc1 - pc1 <addr_min [addr_max]>/off, set break point PC1\n");
434 printk(" pc2 - pc2 <addr_min [addr_max]>/off, set break point PC2\n");
435 printk(" pc3 - pc3 <addr_min [addr_max]>/off, set break point PC3\n");
436 printk(" daddr0 - daddr0 <addr_min [addr_max] r/w/rw [value]>/off, set break point data address 0\n");
437 printk(" daddr1 - daddr1 <addr_min [addr_max] r/w/rw [value]>/off, set break point data address 1\n");
438 printk(" help - print this screen\n");
439 }
440  
441 return count;
442 }
443  
444 #else
445  
446 static int proc_read_pp32(char *page, char **start, off_t off, int count, int *eof, void *data)
447 {
448 static const char *stron = " on";
449 static const char *stroff = "off";
450  
451 int len = 0;
452 int cur_context;
453 int f_stopped;
454 char str[256];
455 char strlength;
456 int i, j;
457  
458 int pp32;
459  
460 for ( pp32 = 0; pp32 < NUM_OF_PP32; pp32++ )
461 {
462 f_stopped = 0;
463  
464 len += sprintf(page + off + len, "===== pp32 core %d =====\n", pp32);
465  
466 #ifdef CONFIG_VR9
467 if ( (*PP32_FREEZE & (1 << (pp32 << 4))) != 0 )
468 {
469 sprintf(str, "freezed");
470 f_stopped = 1;
471 }
472 #else
473 if ( 0 )
474 {
475 }
476 #endif
477 else if ( PP32_CPU_USER_STOPPED(pp32) || PP32_CPU_USER_BREAKIN_RCV(pp32) || PP32_CPU_USER_BREAKPOINT_MET(pp32) )
478 {
479 strlength = 0;
480 if ( PP32_CPU_USER_STOPPED(pp32) )
481 strlength += sprintf(str + strlength, "stopped");
482 if ( PP32_CPU_USER_BREAKPOINT_MET(pp32) )
483 strlength += sprintf(str + strlength, strlength ? " | breakpoint" : "breakpoint");
484 if ( PP32_CPU_USER_BREAKIN_RCV(pp32) )
485 strlength += sprintf(str + strlength, strlength ? " | breakin" : "breakin");
486 f_stopped = 1;
487 }
488 else if ( PP32_CPU_CUR_PC(pp32) == PP32_CPU_CUR_PC(pp32) )
489 {
490 unsigned int pc_value[64] = {0};
491  
492 f_stopped = 1;
493 for ( i = 0; f_stopped && i < NUM_ENTITY(pc_value); i++ )
494 {
495 pc_value[i] = PP32_CPU_CUR_PC(pp32);
496 for ( j = 0; j < i; j++ )
497 if ( pc_value[j] != pc_value[i] )
498 {
499 f_stopped = 0;
500 break;
501 }
502 }
503 if ( f_stopped )
504 sprintf(str, "hang");
505 }
506 if ( !f_stopped )
507 sprintf(str, "running");
508 cur_context = PP32_BRK_CUR_CONTEXT(pp32);
509 len += sprintf(page + off + len, "Context: %d, PC: 0x%04x, %s\n", cur_context, PP32_CPU_CUR_PC(pp32), str);
510  
511 if ( PP32_CPU_USER_BREAKPOINT_MET(pp32) )
512 {
513 strlength = 0;
514 if ( PP32_BRK_PC_MET(pp32, 0) )
515 strlength += sprintf(str + strlength, "pc0");
516 if ( PP32_BRK_PC_MET(pp32, 1) )
517 strlength += sprintf(str + strlength, strlength ? " | pc1" : "pc1");
518 if ( PP32_BRK_DATA_ADDR_MET(pp32, 0) )
519 strlength += sprintf(str + strlength, strlength ? " | daddr0" : "daddr0");
520 if ( PP32_BRK_DATA_ADDR_MET(pp32, 1) )
521 strlength += sprintf(str + strlength, strlength ? " | daddr1" : "daddr1");
522 if ( PP32_BRK_DATA_VALUE_RD_MET(pp32, 0) )
523 {
524 strlength += sprintf(str + strlength, strlength ? " | rdval0" : "rdval0");
525 if ( PP32_BRK_DATA_VALUE_RD_LO_EQ(pp32, 0) )
526 {
527 if ( PP32_BRK_DATA_VALUE_RD_GT_EQ(pp32, 0) )
528 strlength += sprintf(str + strlength, " ==");
529 else
530 strlength += sprintf(str + strlength, " <=");
531 }
532 else if ( PP32_BRK_DATA_VALUE_RD_GT_EQ(pp32, 0) )
533 strlength += sprintf(str + strlength, " >=");
534 }
535 if ( PP32_BRK_DATA_VALUE_RD_MET(pp32, 1) )
536 {
537 strlength += sprintf(str + strlength, strlength ? " | rdval1" : "rdval1");
538 if ( PP32_BRK_DATA_VALUE_RD_LO_EQ(pp32, 1) )
539 {
540 if ( PP32_BRK_DATA_VALUE_RD_GT_EQ(pp32, 1) )
541 strlength += sprintf(str + strlength, " ==");
542 else
543 strlength += sprintf(str + strlength, " <=");
544 }
545 else if ( PP32_BRK_DATA_VALUE_RD_GT_EQ(pp32, 1) )
546 strlength += sprintf(str + strlength, " >=");
547 }
548 if ( PP32_BRK_DATA_VALUE_WR_MET(pp32, 0) )
549 {
550 strlength += sprintf(str + strlength, strlength ? " | wtval0" : "wtval0");
551 if ( PP32_BRK_DATA_VALUE_WR_LO_EQ(pp32, 0) )
552 {
553 if ( PP32_BRK_DATA_VALUE_WR_GT_EQ(pp32, 0) )
554 strlength += sprintf(str + strlength, " ==");
555 else
556 strlength += sprintf(str + strlength, " <=");
557 }
558 else if ( PP32_BRK_DATA_VALUE_WR_GT_EQ(pp32, 0) )
559 strlength += sprintf(str + strlength, " >=");
560 }
561 if ( PP32_BRK_DATA_VALUE_WR_MET(pp32, 1) )
562 {
563 strlength += sprintf(str + strlength, strlength ? " | wtval1" : "wtval1");
564 if ( PP32_BRK_DATA_VALUE_WR_LO_EQ(pp32, 1) )
565 {
566 if ( PP32_BRK_DATA_VALUE_WR_GT_EQ(pp32, 1) )
567 strlength += sprintf(str + strlength, " ==");
568 else
569 strlength += sprintf(str + strlength, " <=");
570 }
571 else if ( PP32_BRK_DATA_VALUE_WR_GT_EQ(pp32, 1) )
572 strlength += sprintf(str + strlength, " >=");
573 }
574 len += sprintf(page + off + len, "break reason: %s\n", str);
575 }
576  
577 if ( f_stopped )
578 {
579 len += sprintf(page + off + len, "General Purpose Register (Context %d):\n", cur_context);
580 for ( i = 0; i < 4; i++ )
581 {
582 for ( j = 0; j < 4; j++ )
583 len += sprintf(page + off + len, " %2d: %08x", i + j * 4, *PP32_GP_CONTEXTi_REGn(pp32, cur_context, i + j * 4));
584 len += sprintf(page + off + len, "\n");
585 }
586 }
587  
588 len += sprintf(page + off + len, "break out on: break in - %s, stop - %s\n",
589 PP32_CTRL_OPT_BREAKOUT_ON_BREAKIN(pp32) ? stron : stroff,
590 PP32_CTRL_OPT_BREAKOUT_ON_STOP(pp32) ? stron : stroff);
591 len += sprintf(page + off + len, " stop on: break in - %s, break point - %s\n",
592 PP32_CTRL_OPT_STOP_ON_BREAKIN(pp32) ? stron : stroff,
593 PP32_CTRL_OPT_STOP_ON_BREAKPOINT(pp32) ? stron : stroff);
594 len += sprintf(page + off + len, "breakpoint:\n");
595 len += sprintf(page + off + len, " pc0: 0x%08x, %s\n", *PP32_BRK_PC(pp32, 0), PP32_BRK_GRPi_PCn(pp32, 0, 0) ? "group 0" : "off");
596 len += sprintf(page + off + len, " pc1: 0x%08x, %s\n", *PP32_BRK_PC(pp32, 1), PP32_BRK_GRPi_PCn(pp32, 1, 1) ? "group 1" : "off");
597 len += sprintf(page + off + len, " daddr0: 0x%08x, %s\n", *PP32_BRK_DATA_ADDR(pp32, 0), PP32_BRK_GRPi_DATA_ADDRn(pp32, 0, 0) ? "group 0" : "off");
598 len += sprintf(page + off + len, " daddr1: 0x%08x, %s\n", *PP32_BRK_DATA_ADDR(pp32, 1), PP32_BRK_GRPi_DATA_ADDRn(pp32, 1, 1) ? "group 1" : "off");
599 len += sprintf(page + off + len, " rdval0: 0x%08x\n", *PP32_BRK_DATA_VALUE_RD(pp32, 0));
600 len += sprintf(page + off + len, " rdval1: 0x%08x\n", *PP32_BRK_DATA_VALUE_RD(pp32, 1));
601 len += sprintf(page + off + len, " wrval0: 0x%08x\n", *PP32_BRK_DATA_VALUE_WR(pp32, 0));
602 len += sprintf(page + off + len, " wrval1: 0x%08x\n", *PP32_BRK_DATA_VALUE_WR(pp32, 1));
603 }
604  
605 *eof = 1;
606  
607 return len;
608 }
609  
610 static int proc_write_pp32(struct file *file, const char *buf, unsigned long count, void *data)
611 {
612 char str[2048];
613 char *p;
614 int len, rlen;
615  
616 int pp32 = 0;
617 u32 addr;
618  
619 len = count < sizeof(str) ? count : sizeof(str) - 1;
620 rlen = len - copy_from_user(str, buf, len);
621 while ( rlen && str[rlen - 1] <= ' ' )
622 rlen--;
623 str[rlen] = 0;
624 for ( p = str; *p && *p <= ' '; p++, rlen-- );
625 if ( !*p )
626 return 0;
627  
628 if ( strincmp(p, "pp32 ", 5) == 0 )
629 {
630 p += 5;
631 rlen -= 5;
632  
633 while ( rlen > 0 && *p >= '0' && *p <= '9' )
634 {
635 pp32 += *p - '0';
636 p++;
637 rlen--;
638 }
639 while ( rlen > 0 && *p && *p <= ' ' )
640 {
641 p++;
642 rlen--;
643 }
644  
645 if ( pp32 >= NUM_OF_PP32 )
646 {
647 printk(KERN_ERR __FILE__ ":%d:%s: incorrect pp32 index - %d\n", __LINE__, __FUNCTION__, pp32);
648 return count;
649 }
650 }
651  
652 if ( stricmp(p, "start") == 0 )
653 {
654 #ifdef CONFIG_AMAZON_SE
655 *PP32_CTRL_CMD(pp32) = 0;
656 #endif
657 *PP32_CTRL_CMD(pp32) = PP32_CTRL_CMD_RESTART;
658 }
659 else if ( stricmp(p, "stop") == 0 )
660 {
661 #ifdef CONFIG_AMAZON_SE
662 *PP32_CTRL_CMD(pp32) = 0;
663 #endif
664 *PP32_CTRL_CMD(pp32) = PP32_CTRL_CMD_STOP;
665 }
666 else if ( stricmp(p, "step") == 0 )
667 {
668 #ifdef CONFIG_AMAZON_SE
669 *PP32_CTRL_CMD(pp32) = 0;
670 #endif
671 *PP32_CTRL_CMD(pp32) = PP32_CTRL_CMD_STEP;
672 }
673 #ifdef CONFIG_VR9
674 else if ( stricmp(p, "unfreeze") == 0 )
675 *PP32_FREEZE &= ~(1 << (pp32 << 4));
676 else if ( stricmp(p, "freeze") == 0 )
677 *PP32_FREEZE |= 1 << (pp32 << 4);
678 #else
679 else if ( stricmp(p, "unfreeze") == 0 )
680 *PP32_DBG_CTRL(pp32) = DBG_CTRL_RESTART;
681 else if ( stricmp(p, "freeze") == 0 )
682 *PP32_DBG_CTRL(pp32) = DBG_CTRL_STOP;
683 #endif
684 else if ( strincmp(p, "pc0 ", 4) == 0 )
685 {
686 p += 4;
687 rlen -= 4;
688 if ( stricmp(p, "off") == 0 )
689 {
690 *PP32_BRK_TRIG(pp32) = PP32_BRK_GRPi_PCn_OFF(0, 0);
691 *PP32_BRK_PC_MASK(pp32, 0) = PP32_BRK_CONTEXT_MASK_EN;
692 *PP32_BRK_PC(pp32, 0) = 0;
693 }
694 else
695 {
696 addr = get_number(&p, &rlen, 1);
697 *PP32_BRK_PC(pp32, 0) = addr;
698 *PP32_BRK_PC_MASK(pp32, 0) = PP32_BRK_CONTEXT_MASK_EN | PP32_BRK_CONTEXT_MASK(0) | PP32_BRK_CONTEXT_MASK(1) | PP32_BRK_CONTEXT_MASK(2) | PP32_BRK_CONTEXT_MASK(3);
699 *PP32_BRK_TRIG(pp32) = PP32_BRK_GRPi_PCn_ON(0, 0);
700 }
701 }
702 else if ( strincmp(p, "pc1 ", 4) == 0 )
703 {
704 p += 4;
705 rlen -= 4;
706 if ( stricmp(p, "off") == 0 )
707 {
708 *PP32_BRK_TRIG(pp32) = PP32_BRK_GRPi_PCn_OFF(1, 1);
709 *PP32_BRK_PC_MASK(pp32, 1) = PP32_BRK_CONTEXT_MASK_EN;
710 *PP32_BRK_PC(pp32, 1) = 0;
711 }
712 else
713 {
714 addr = get_number(&p, &rlen, 1);
715 *PP32_BRK_PC(pp32, 1) = addr;
716 *PP32_BRK_PC_MASK(pp32, 1) = PP32_BRK_CONTEXT_MASK_EN | PP32_BRK_CONTEXT_MASK(0) | PP32_BRK_CONTEXT_MASK(1) | PP32_BRK_CONTEXT_MASK(2) | PP32_BRK_CONTEXT_MASK(3);
717 *PP32_BRK_TRIG(pp32) = PP32_BRK_GRPi_PCn_ON(1, 1);
718 }
719 }
720 else if ( strincmp(p, "daddr0 ", 7) == 0 )
721 {
722 p += 7;
723 rlen -= 7;
724 if ( stricmp(p, "off") == 0 )
725 {
726 *PP32_BRK_TRIG(pp32) = PP32_BRK_GRPi_DATA_ADDRn_OFF(0, 0);
727 *PP32_BRK_DATA_ADDR_MASK(pp32, 0) = PP32_BRK_CONTEXT_MASK_EN;
728 *PP32_BRK_DATA_ADDR(pp32, 0) = 0;
729 }
730 else
731 {
732 addr = get_number(&p, &rlen, 1);
733 *PP32_BRK_DATA_ADDR(pp32, 0) = addr;
734 *PP32_BRK_DATA_ADDR_MASK(pp32, 0) = PP32_BRK_CONTEXT_MASK_EN | PP32_BRK_CONTEXT_MASK(0) | PP32_BRK_CONTEXT_MASK(1) | PP32_BRK_CONTEXT_MASK(2) | PP32_BRK_CONTEXT_MASK(3);
735 *PP32_BRK_TRIG(pp32) = PP32_BRK_GRPi_DATA_ADDRn_ON(0, 0);
736 }
737 }
738 else if ( strincmp(p, "daddr1 ", 7) == 0 )
739 {
740 p += 7;
741 rlen -= 7;
742 if ( stricmp(p, "off") == 0 )
743 {
744 *PP32_BRK_TRIG(pp32) = PP32_BRK_GRPi_DATA_ADDRn_OFF(1, 1);
745 *PP32_BRK_DATA_ADDR_MASK(pp32, 1) = PP32_BRK_CONTEXT_MASK_EN;
746 *PP32_BRK_DATA_ADDR(pp32, 1) = 0;
747 }
748 else
749 {
750 addr = get_number(&p, &rlen, 1);
751 *PP32_BRK_DATA_ADDR(pp32, 1) = addr;
752 *PP32_BRK_DATA_ADDR_MASK(pp32, 1) = PP32_BRK_CONTEXT_MASK_EN | PP32_BRK_CONTEXT_MASK(0) | PP32_BRK_CONTEXT_MASK(1) | PP32_BRK_CONTEXT_MASK(2) | PP32_BRK_CONTEXT_MASK(3);
753 *PP32_BRK_TRIG(pp32) = PP32_BRK_GRPi_DATA_ADDRn_ON(1, 1);
754 }
755 }
756 else
757 {
758  
759 printk("echo \"<command>\" > /proc/driver/ifx_ptm/pp32\n");
760 printk(" command:\n");
761 printk(" unfreeze - unfreeze pp32\n");
762 printk(" freeze - freeze pp32\n");
763 printk(" start - run pp32\n");
764 printk(" stop - stop pp32\n");
765 printk(" step - run pp32 with one step only\n");
766 printk(" pc0 - pc0 <addr>/off, set break point PC0\n");
767 printk(" pc1 - pc1 <addr>/off, set break point PC1\n");
768 printk(" daddr0 - daddr0 <addr>/off, set break point data address 0\n");
769 printk(" daddr1 - daddr1 <addr>/off, set break point data address 1\n");
770 printk(" help - print this screen\n");
771 }
772  
773 if ( *PP32_BRK_TRIG(pp32) )
774 *PP32_CTRL_OPT(pp32) = PP32_CTRL_OPT_STOP_ON_BREAKPOINT_ON;
775 else
776 *PP32_CTRL_OPT(pp32) = PP32_CTRL_OPT_STOP_ON_BREAKPOINT_OFF;
777  
778 return count;
779 }
780  
781 #endif
782  
783 static int stricmp(const char *p1, const char *p2)
784 {
785 int c1, c2;
786  
787 while ( *p1 && *p2 )
788 {
789 c1 = *p1 >= 'A' && *p1 <= 'Z' ? *p1 + 'a' - 'A' : *p1;
790 c2 = *p2 >= 'A' && *p2 <= 'Z' ? *p2 + 'a' - 'A' : *p2;
791 if ( (c1 -= c2) )
792 return c1;
793 p1++;
794 p2++;
795 }
796  
797 return *p1 - *p2;
798 }
799  
800 static int strincmp(const char *p1, const char *p2, int n)
801 {
802 int c1 = 0, c2;
803  
804 while ( n && *p1 && *p2 )
805 {
806 c1 = *p1 >= 'A' && *p1 <= 'Z' ? *p1 + 'a' - 'A' : *p1;
807 c2 = *p2 >= 'A' && *p2 <= 'Z' ? *p2 + 'a' - 'A' : *p2;
808 if ( (c1 -= c2) )
809 return c1;
810 p1++;
811 p2++;
812 n--;
813 }
814  
815 return n ? *p1 - *p2 : c1;
816 }
817  
818 static int get_token(char **p1, char **p2, int *len, int *colon)
819 {
820 int tlen = 0;
821  
822 while ( *len && !((**p1 >= 'A' && **p1 <= 'Z') || (**p1 >= 'a' && **p1<= 'z')) )
823 {
824 (*p1)++;
825 (*len)--;
826 }
827 if ( !*len )
828 return 0;
829  
830 if ( *colon )
831 {
832 *colon = 0;
833 *p2 = *p1;
834 while ( *len && **p2 > ' ' && **p2 != ',' )
835 {
836 if ( **p2 == ':' )
837 {
838 *colon = 1;
839 break;
840 }
841 (*p2)++;
842 (*len)--;
843 tlen++;
844 }
845 **p2 = 0;
846 }
847 else
848 {
849 *p2 = *p1;
850 while ( *len && **p2 > ' ' && **p2 != ',' )
851 {
852 (*p2)++;
853 (*len)--;
854 tlen++;
855 }
856 **p2 = 0;
857 }
858  
859 return tlen;
860 }
861  
862 static int get_number(char **p, int *len, int is_hex)
863 {
864 int ret = 0;
865 int n = 0;
866  
867 if ( (*p)[0] == '0' && (*p)[1] == 'x' )
868 {
869 is_hex = 1;
870 (*p) += 2;
871 (*len) -= 2;
872 }
873  
874 if ( is_hex )
875 {
876 while ( *len && ((**p >= '0' && **p <= '9') || (**p >= 'a' && **p <= 'f') || (**p >= 'A' && **p <= 'F')) )
877 {
878 if ( **p >= '0' && **p <= '9' )
879 n = **p - '0';
880 else if ( **p >= 'a' && **p <= 'f' )
881 n = **p - 'a' + 10;
882 else if ( **p >= 'A' && **p <= 'F' )
883 n = **p - 'A' + 10;
884 ret = (ret << 4) | n;
885 (*p)++;
886 (*len)--;
887 }
888 }
889 else
890 {
891 while ( *len && **p >= '0' && **p <= '9' )
892 {
893 n = **p - '0';
894 ret = ret * 10 + n;
895 (*p)++;
896 (*len)--;
897 }
898 }
899  
900 return ret;
901 }
902  
903 static inline void ignore_space(char **p, int *len)
904 {
905 while ( *len && (**p <= ' ' || **p == ':' || **p == '.' || **p == ',') )
906 {
907 (*p)++;
908 (*len)--;
909 }
910 }
911  
912  
913  
914 /*
915 * ####################################
916 * Global Function
917 * ####################################
918 */
919  
920  
921  
922 /*
923 * ####################################
924 * Init/Cleanup API
925 * ####################################
926 */
927  
928 static int __init ifx_ptm_test_init(void)
929 {
930 proc_file_create();
931  
932 return 0;
933 }
934  
935 static void __exit ifx_ptm_test_exit(void)
936 {
937 proc_file_delete();
938 }
939  
940 module_init(ifx_ptm_test_init);
941 module_exit(ifx_ptm_test_exit);
942  
943 #endif