projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'v3.10.55' into update
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / arch / arm / kernel / etm.c
1 /*
2 * linux/arch/arm/kernel/etm.c
3 *
4 * Driver for ARM's Embedded Trace Macrocell and Embedded Trace Buffer.
5 *
6 * Copyright (C) 2009 Nokia Corporation.
7 * Alexander Shishkin
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
12 */
13
14 #include <linux/kernel.h>
15 #include <linux/init.h>
16 #include <linux/types.h>
17 #include <linux/io.h>
18 #include <linux/slab.h>
19 #include <linux/sysrq.h>
20 #include <linux/device.h>
21 #include <linux/clk.h>
22 #include <linux/amba/bus.h>
23 #include <linux/fs.h>
24 #include <linux/uaccess.h>
25 #include <linux/miscdevice.h>
26 #include <linux/vmalloc.h>
27 #include <linux/mutex.h>
28 #include <linux/module.h>
29 #include <asm/hardware/coresight.h>
30 #include <asm/sections.h>
31
32 MODULE_LICENSE("GPL");
33 MODULE_AUTHOR("Alexander Shishkin");
34
35 /*
36 * ETM tracer state
37 */
38 struct tracectx {
39 unsigned int etb_bufsz;
40 void __iomem *etb_regs;
41 void __iomem **etm_regs;
42 int etm_regs_count;
43 unsigned long flags;
44 int ncmppairs;
45 int etm_portsz;
46 int etm_contextid_size;
47 u32 etb_fc;
48 unsigned long range_start;
49 unsigned long range_end;
50 unsigned long data_range_start;
51 unsigned long data_range_end;
52 bool dump_initial_etb;
53 struct device *dev;
54 struct clk *emu_clk;
55 struct mutex mutex;
56 };
57
58 static struct tracectx tracer = {
59 .range_start = (unsigned long)_stext,
60 .range_end = (unsigned long)_etext,
61 };
62
63 static inline bool trace_isrunning(struct tracectx *t)
64 {
65 return !!(t->flags & TRACER_RUNNING);
66 }
67
68 static int etm_setup_address_range(struct tracectx *t, int id, int n,
69 unsigned long start, unsigned long end, int exclude, int data)
70 {
71 u32 flags = ETMAAT_ARM | ETMAAT_IGNCONTEXTID | ETMAAT_IGNSECURITY |
72 ETMAAT_NOVALCMP;
73
74 if (n < 1 || n > t->ncmppairs)
75 return -EINVAL;
76
77 /* comparators and ranges are numbered starting with 1 as opposed
78 * to bits in a word */
79 n--;
80
81 if (data)
82 flags |= ETMAAT_DLOADSTORE;
83 else
84 flags |= ETMAAT_IEXEC;
85
86 /* first comparator for the range */
87 etm_writel(t, id, flags, ETMR_COMP_ACC_TYPE(n * 2));
88 etm_writel(t, id, start, ETMR_COMP_VAL(n * 2));
89
90 /* second comparator is right next to it */
91 etm_writel(t, id, flags, ETMR_COMP_ACC_TYPE(n * 2 + 1));
92 etm_writel(t, id, end, ETMR_COMP_VAL(n * 2 + 1));
93
94 if (data) {
95 flags = exclude ? ETMVDC3_EXCLONLY : 0;
96 if (exclude)
97 n += 8;
98 etm_writel(t, id, flags | BIT(n), ETMR_VIEWDATACTRL3);
99 } else {
100 flags = exclude ? ETMTE_INCLEXCL : 0;
101 etm_writel(t, id, flags | (1 << n), ETMR_TRACEENCTRL);
102 }
103
104 return 0;
105 }
106
107 static int trace_start_etm(struct tracectx *t, int id)
108 {
109 u32 v;
110 unsigned long timeout = TRACER_TIMEOUT;
111
112 v = ETMCTRL_OPTS | ETMCTRL_PROGRAM | ETMCTRL_PORTSIZE(t->etm_portsz);
113 v |= ETMCTRL_CONTEXTIDSIZE(t->etm_contextid_size);
114
115 if (t->flags & TRACER_CYCLE_ACC)
116 v |= ETMCTRL_CYCLEACCURATE;
117
118 if (t->flags & TRACER_BRANCHOUTPUT)
119 v |= ETMCTRL_BRANCH_OUTPUT;
120
121 if (t->flags & TRACER_TRACE_DATA)
122 v |= ETMCTRL_DATA_DO_ADDR;
123
124 if (t->flags & TRACER_TIMESTAMP)
125 v |= ETMCTRL_TIMESTAMP_EN;
126
127 if (t->flags & TRACER_RETURN_STACK)
128 v |= ETMCTRL_RETURN_STACK_EN;
129
130 etm_unlock(t, id);
131
132 etm_writel(t, id, v, ETMR_CTRL);
133
134 while (!(etm_readl(t, id, ETMR_CTRL) & ETMCTRL_PROGRAM) && --timeout)
135 ;
136 if (!timeout) {
137 dev_dbg(t->dev, "Waiting for progbit to assert timed out\n");
138 etm_lock(t, id);
139 return -EFAULT;
140 }
141
142 if (t->range_start || t->range_end)
143 etm_setup_address_range(t, id, 1,
144 t->range_start, t->range_end, 0, 0);
145 else
146 etm_writel(t, id, ETMTE_INCLEXCL, ETMR_TRACEENCTRL);
147
148 etm_writel(t, id, 0, ETMR_TRACEENCTRL2);
149 etm_writel(t, id, 0, ETMR_TRACESSCTRL);
150 etm_writel(t, id, 0x6f, ETMR_TRACEENEVT);
151
152 etm_writel(t, id, 0, ETMR_VIEWDATACTRL1);
153 etm_writel(t, id, 0, ETMR_VIEWDATACTRL2);
154
155 if (t->data_range_start || t->data_range_end)
156 etm_setup_address_range(t, id, 2, t->data_range_start,
157 t->data_range_end, 0, 1);
158 else
159 etm_writel(t, id, ETMVDC3_EXCLONLY, ETMR_VIEWDATACTRL3);
160
161 etm_writel(t, id, 0x6f, ETMR_VIEWDATAEVT);
162
163 v &= ~ETMCTRL_PROGRAM;
164 v |= ETMCTRL_PORTSEL;
165
166 etm_writel(t, id, v, ETMR_CTRL);
167
168 timeout = TRACER_TIMEOUT;
169 while (etm_readl(t, id, ETMR_CTRL) & ETMCTRL_PROGRAM && --timeout)
170 ;
171 if (!timeout) {
172 dev_dbg(t->dev, "Waiting for progbit to deassert timed out\n");
173 etm_lock(t, id);
174 return -EFAULT;
175 }
176
177 etm_lock(t, id);
178 return 0;
179 }
180
181 static int trace_start(struct tracectx *t)
182 {
183 int ret;
184 int id;
185 u32 etb_fc = t->etb_fc;
186
187 etb_unlock(t);
188
189 t->dump_initial_etb = false;
190 etb_writel(t, 0, ETBR_WRITEADDR);
191 etb_writel(t, etb_fc, ETBR_FORMATTERCTRL);
192 etb_writel(t, 1, ETBR_CTRL);
193
194 etb_lock(t);
195
196 /* configure etm(s) */
197 for (id = 0; id < t->etm_regs_count; id++) {
198 ret = trace_start_etm(t, id);
199 if (ret)
200 return ret;
201 }
202
203 t->flags |= TRACER_RUNNING;
204
205 return 0;
206 }
207
208 static int trace_stop_etm(struct tracectx *t, int id)
209 {
210 unsigned long timeout = TRACER_TIMEOUT;
211
212 etm_unlock(t, id);
213
214 etm_writel(t, id, 0x440, ETMR_CTRL);
215 while (!(etm_readl(t, id, ETMR_CTRL) & ETMCTRL_PROGRAM) && --timeout)
216 ;
217 if (!timeout) {
218 dev_err(t->dev,
219 "etm%d: Waiting for progbit to assert timed out\n",
220 id);
221 etm_lock(t, id);
222 return -EFAULT;
223 }
224
225 etm_lock(t, id);
226 return 0;
227 }
228
229 static int trace_power_down_etm(struct tracectx *t, int id)
230 {
231 unsigned long timeout = TRACER_TIMEOUT;
232 etm_unlock(t, id);
233 while (!(etm_readl(t, id, ETMR_STATUS) & ETMST_PROGBIT) && --timeout)
234 ;
235 if (!timeout) {
236 dev_err(t->dev, "etm%d: Waiting for status progbit to assert timed out\n",
237 id);
238 etm_lock(t, id);
239 return -EFAULT;
240 }
241
242 etm_writel(t, id, 0x441, ETMR_CTRL);
243
244 etm_lock(t, id);
245 return 0;
246 }
247
248 static int trace_stop(struct tracectx *t)
249 {
250 int id;
251 unsigned long timeout = TRACER_TIMEOUT;
252 u32 etb_fc = t->etb_fc;
253
254 for (id = 0; id < t->etm_regs_count; id++)
255 trace_stop_etm(t, id);
256
257 for (id = 0; id < t->etm_regs_count; id++)
258 trace_power_down_etm(t, id);
259
260 etb_unlock(t);
261 if (etb_fc) {
262 etb_fc |= ETBFF_STOPFL;
263 etb_writel(t, t->etb_fc, ETBR_FORMATTERCTRL);
264 }
265 etb_writel(t, etb_fc | ETBFF_MANUAL_FLUSH, ETBR_FORMATTERCTRL);
266
267 timeout = TRACER_TIMEOUT;
268 while (etb_readl(t, ETBR_FORMATTERCTRL) &
269 ETBFF_MANUAL_FLUSH && --timeout)
270 ;
271 if (!timeout) {
272 dev_dbg(t->dev, "Waiting for formatter flush to commence "
273 "timed out\n");
274 etb_lock(t);
275 return -EFAULT;
276 }
277
278 etb_writel(t, 0, ETBR_CTRL);
279
280 etb_lock(t);
281
282 t->flags &= ~TRACER_RUNNING;
283
284 return 0;
285 }
286
287 static int etb_getdatalen(struct tracectx *t)
288 {
289 u32 v;
290 int wp;
291
292 v = etb_readl(t, ETBR_STATUS);
293
294 if (v & 1)
295 return t->etb_bufsz;
296
297 wp = etb_readl(t, ETBR_WRITEADDR);
298 return wp;
299 }
300
301 /* sysrq+v will always stop the running trace and leave it at that */
302 static void etm_dump(void)
303 {
304 struct tracectx *t = &tracer;
305 u32 first = 0;
306 int length;
307
308 if (!t->etb_regs) {
309 printk(KERN_INFO "No tracing hardware found\n");
310 return;
311 }
312
313 if (trace_isrunning(t))
314 trace_stop(t);
315
316 etb_unlock(t);
317
318 length = etb_getdatalen(t);
319
320 if (length == t->etb_bufsz)
321 first = etb_readl(t, ETBR_WRITEADDR);
322
323 etb_writel(t, first, ETBR_READADDR);
324
325 printk(KERN_INFO "Trace buffer contents length: %d\n", length);
326 printk(KERN_INFO "--- ETB buffer begin ---\n");
327 for (; length; length--)
328 printk("%08x", cpu_to_be32(etb_readl(t, ETBR_READMEM)));
329 printk(KERN_INFO "\n--- ETB buffer end ---\n");
330
331 etb_lock(t);
332 }
333
334 static void sysrq_etm_dump(int key)
335 {
336 if (!mutex_trylock(&tracer.mutex)) {
337 printk(KERN_INFO "Tracing hardware busy\n");
338 return;
339 }
340 dev_dbg(tracer.dev, "Dumping ETB buffer\n");
341 etm_dump();
342 mutex_unlock(&tracer.mutex);
343 }
344
345 static struct sysrq_key_op sysrq_etm_op = {
346 .handler = sysrq_etm_dump,
347 .help_msg = "etm-buffer-dump(v)",
348 .action_msg = "etm",
349 };
350
351 static int etb_open(struct inode *inode, struct file *file)
352 {
353 if (!tracer.etb_regs)
354 return -ENODEV;
355
356 file->private_data = &tracer;
357
358 return nonseekable_open(inode, file);
359 }
360
361 static ssize_t etb_read(struct file *file, char __user *data,
362 size_t len, loff_t *ppos)
363 {
364 int total, i;
365 long length;
366 struct tracectx *t = file->private_data;
367 u32 first = 0;
368 u32 *buf;
369 int wpos;
370 int skip;
371 long wlength;
372 loff_t pos = *ppos;
373
374 mutex_lock(&t->mutex);
375
376 if (trace_isrunning(t)) {
377 length = 0;
378 goto out;
379 }
380
381 etb_unlock(t);
382
383 total = etb_getdatalen(t);
384 if (total == 0 && t->dump_initial_etb)
385 total = t->etb_bufsz;
386 if (total == t->etb_bufsz)
387 first = etb_readl(t, ETBR_WRITEADDR);
388
389 if (pos > total * 4) {
390 skip = 0;
391 wpos = total;
392 } else {
393 skip = (int)pos % 4;
394 wpos = (int)pos / 4;
395 }
396 total -= wpos;
397 first = (first + wpos) % t->etb_bufsz;
398
399 etb_writel(t, first, ETBR_READADDR);
400
401 wlength = min(total, DIV_ROUND_UP(skip + (int)len, 4));
402 length = min(total * 4 - skip, (int)len);
403 buf = vmalloc(wlength * 4);
404
405 dev_dbg(t->dev, "ETB read %ld bytes to %lld from %ld words at %d\n",
406 length, pos, wlength, first);
407 dev_dbg(t->dev, "ETB buffer length: %d\n", total + wpos);
408 dev_dbg(t->dev, "ETB status reg: %x\n", etb_readl(t, ETBR_STATUS));
409 for (i = 0; i < wlength; i++)
410 buf[i] = etb_readl(t, ETBR_READMEM);
411
412 etb_lock(t);
413
414 length -= copy_to_user(data, (u8 *)buf + skip, length);
415 vfree(buf);
416 *ppos = pos + length;
417
418 out:
419 mutex_unlock(&t->mutex);
420
421 return length;
422 }
423
424 static int etb_release(struct inode *inode, struct file *file)
425 {
426 /* there's nothing to do here, actually */
427 return 0;
428 }
429
430 static const struct file_operations etb_fops = {
431 .owner = THIS_MODULE,
432 .read = etb_read,
433 .open = etb_open,
434 .release = etb_release,
435 .llseek = no_llseek,
436 };
437
438 static struct miscdevice etb_miscdev = {
439 .name = "tracebuf",
440 .minor = 0,
441 .fops = &etb_fops,
442 };
443
444 static int etb_probe(struct amba_device *dev, const struct amba_id *id)
445 {
446 struct tracectx *t = &tracer;
447 int ret = 0;
448
449 ret = amba_request_regions(dev, NULL);
450 if (ret)
451 goto out;
452
453 mutex_lock(&t->mutex);
454 t->etb_regs = ioremap_nocache(dev->res.start, resource_size(&dev->res));
455 if (!t->etb_regs) {
456 ret = -ENOMEM;
457 goto out_release;
458 }
459
460 t->dev = &dev->dev;
461 t->dump_initial_etb = true;
462 amba_set_drvdata(dev, t);
463
464 etb_unlock(t);
465 t->etb_bufsz = etb_readl(t, ETBR_DEPTH);
466 dev_dbg(&dev->dev, "Size: %x\n", t->etb_bufsz);
467
468 /* make sure trace capture is disabled */
469 etb_writel(t, 0, ETBR_CTRL);
470 etb_writel(t, 0x1000, ETBR_FORMATTERCTRL);
471 etb_lock(t);
472 mutex_unlock(&t->mutex);
473
474 etb_miscdev.parent = &dev->dev;
475
476 ret = misc_register(&etb_miscdev);
477 if (ret)
478 goto out_unmap;
479
480 /* Get optional clock. Currently used to select clock source on omap3 */
481 t->emu_clk = clk_get(&dev->dev, "emu_src_ck");
482 if (IS_ERR(t->emu_clk))
483 dev_dbg(&dev->dev, "Failed to obtain emu_src_ck.\n");
484 else
485 clk_enable(t->emu_clk);
486
487 dev_dbg(&dev->dev, "ETB AMBA driver initialized.\n");
488
489 out:
490 return ret;
491
492 out_unmap:
493 mutex_lock(&t->mutex);
494 amba_set_drvdata(dev, NULL);
495 iounmap(t->etb_regs);
496 t->etb_regs = NULL;
497
498 out_release:
499 mutex_unlock(&t->mutex);
500 amba_release_regions(dev);
501
502 return ret;
503 }
504
505 static int etb_remove(struct amba_device *dev)
506 {
507 struct tracectx *t = amba_get_drvdata(dev);
508
509 amba_set_drvdata(dev, NULL);
510
511 iounmap(t->etb_regs);
512 t->etb_regs = NULL;
513
514 if (!IS_ERR(t->emu_clk)) {
515 clk_disable(t->emu_clk);
516 clk_put(t->emu_clk);
517 }
518
519 amba_release_regions(dev);
520
521 return 0;
522 }
523
524 static struct amba_id etb_ids[] = {
525 {
526 .id = 0x0003b907,
527 .mask = 0x0007ffff,
528 },
529 { 0, 0 },
530 };
531
532 static struct amba_driver etb_driver = {
533 .drv = {
534 .name = "etb",
535 .owner = THIS_MODULE,
536 },
537 .probe = etb_probe,
538 .remove = etb_remove,
539 .id_table = etb_ids,
540 };
541
542 /* use a sysfs file "trace_running" to start/stop tracing */
543 static ssize_t trace_running_show(struct kobject *kobj,
544 struct kobj_attribute *attr,
545 char *buf)
546 {
547 return sprintf(buf, "%x\n", trace_isrunning(&tracer));
548 }
549
550 static ssize_t trace_running_store(struct kobject *kobj,
551 struct kobj_attribute *attr,
552 const char *buf, size_t n)
553 {
554 unsigned int value;
555 int ret;
556
557 if (sscanf(buf, "%u", &value) != 1)
558 return -EINVAL;
559
560 mutex_lock(&tracer.mutex);
561 if (!tracer.etb_regs)
562 ret = -ENODEV;
563 else
564 ret = value ? trace_start(&tracer) : trace_stop(&tracer);
565 mutex_unlock(&tracer.mutex);
566
567 return ret ? : n;
568 }
569
570 static struct kobj_attribute trace_running_attr =
571 __ATTR(trace_running, 0644, trace_running_show, trace_running_store);
572
573 static ssize_t trace_info_show(struct kobject *kobj,
574 struct kobj_attribute *attr,
575 char *buf)
576 {
577 u32 etb_wa, etb_ra, etb_st, etb_fc, etm_ctrl, etm_st;
578 int datalen;
579 int id;
580 int ret;
581
582 mutex_lock(&tracer.mutex);
583 if (tracer.etb_regs) {
584 etb_unlock(&tracer);
585 datalen = etb_getdatalen(&tracer);
586 etb_wa = etb_readl(&tracer, ETBR_WRITEADDR);
587 etb_ra = etb_readl(&tracer, ETBR_READADDR);
588 etb_st = etb_readl(&tracer, ETBR_STATUS);
589 etb_fc = etb_readl(&tracer, ETBR_FORMATTERCTRL);
590 etb_lock(&tracer);
591 } else {
592 etb_wa = etb_ra = etb_st = etb_fc = ~0;
593 datalen = -1;
594 }
595
596 ret = sprintf(buf, "Trace buffer len: %d\nComparator pairs: %d\n"
597 "ETBR_WRITEADDR:\t%08x\n"
598 "ETBR_READADDR:\t%08x\n"
599 "ETBR_STATUS:\t%08x\n"
600 "ETBR_FORMATTERCTRL:\t%08x\n",
601 datalen,
602 tracer.ncmppairs,
603 etb_wa,
604 etb_ra,
605 etb_st,
606 etb_fc
607 );
608
609 for (id = 0; id < tracer.etm_regs_count; id++) {
610 etm_unlock(&tracer, id);
611 etm_ctrl = etm_readl(&tracer, id, ETMR_CTRL);
612 etm_st = etm_readl(&tracer, id, ETMR_STATUS);
613 etm_lock(&tracer, id);
614 ret += sprintf(buf + ret, "ETMR_CTRL:\t%08x\n"
615 "ETMR_STATUS:\t%08x\n",
616 etm_ctrl,
617 etm_st
618 );
619 }
620 mutex_unlock(&tracer.mutex);
621
622 return ret;
623 }
624
625 static struct kobj_attribute trace_info_attr =
626 __ATTR(trace_info, 0444, trace_info_show, NULL);
627
628 static ssize_t trace_mode_show(struct kobject *kobj,
629 struct kobj_attribute *attr,
630 char *buf)
631 {
632 return sprintf(buf, "%d %d\n",
633 !!(tracer.flags & TRACER_CYCLE_ACC),
634 tracer.etm_portsz);
635 }
636
637 static ssize_t trace_mode_store(struct kobject *kobj,
638 struct kobj_attribute *attr,
639 const char *buf, size_t n)
640 {
641 unsigned int cycacc, portsz;
642
643 if (sscanf(buf, "%u %u", &cycacc, &portsz) != 2)
644 return -EINVAL;
645
646 mutex_lock(&tracer.mutex);
647 if (cycacc)
648 tracer.flags |= TRACER_CYCLE_ACC;
649 else
650 tracer.flags &= ~TRACER_CYCLE_ACC;
651
652 tracer.etm_portsz = portsz & 0x0f;
653 mutex_unlock(&tracer.mutex);
654
655 return n;
656 }
657
658 static struct kobj_attribute trace_mode_attr =
659 __ATTR(trace_mode, 0644, trace_mode_show, trace_mode_store);
660
661 static ssize_t trace_contextid_size_show(struct kobject *kobj,
662 struct kobj_attribute *attr,
663 char *buf)
664 {
665 /* 0: No context id tracing, 1: One byte, 2: Two bytes, 3: Four bytes */
666 return sprintf(buf, "%d\n", (1 << tracer.etm_contextid_size) >> 1);
667 }
668
669 static ssize_t trace_contextid_size_store(struct kobject *kobj,
670 struct kobj_attribute *attr,
671 const char *buf, size_t n)
672 {
673 unsigned int contextid_size;
674
675 if (sscanf(buf, "%u", &contextid_size) != 1)
676 return -EINVAL;
677
678 if (contextid_size == 3 || contextid_size > 4)
679 return -EINVAL;
680
681 mutex_lock(&tracer.mutex);
682 tracer.etm_contextid_size = fls(contextid_size);
683 mutex_unlock(&tracer.mutex);
684
685 return n;
686 }
687
688 static struct kobj_attribute trace_contextid_size_attr =
689 __ATTR(trace_contextid_size, 0644,
690 trace_contextid_size_show, trace_contextid_size_store);
691
692 static ssize_t trace_branch_output_show(struct kobject *kobj,
693 struct kobj_attribute *attr,
694 char *buf)
695 {
696 return sprintf(buf, "%d\n", !!(tracer.flags & TRACER_BRANCHOUTPUT));
697 }
698
699 static ssize_t trace_branch_output_store(struct kobject *kobj,
700 struct kobj_attribute *attr,
701 const char *buf, size_t n)
702 {
703 unsigned int branch_output;
704
705 if (sscanf(buf, "%u", &branch_output) != 1)
706 return -EINVAL;
707
708 mutex_lock(&tracer.mutex);
709 if (branch_output) {
710 tracer.flags |= TRACER_BRANCHOUTPUT;
711 /* Branch broadcasting is incompatible with the return stack */
712 tracer.flags &= ~TRACER_RETURN_STACK;
713 } else {
714 tracer.flags &= ~TRACER_BRANCHOUTPUT;
715 }
716 mutex_unlock(&tracer.mutex);
717
718 return n;
719 }
720
721 static struct kobj_attribute trace_branch_output_attr =
722 __ATTR(trace_branch_output, 0644,
723 trace_branch_output_show, trace_branch_output_store);
724
725 static ssize_t trace_return_stack_show(struct kobject *kobj,
726 struct kobj_attribute *attr,
727 char *buf)
728 {
729 return sprintf(buf, "%d\n", !!(tracer.flags & TRACER_RETURN_STACK));
730 }
731
732 static ssize_t trace_return_stack_store(struct kobject *kobj,
733 struct kobj_attribute *attr,
734 const char *buf, size_t n)
735 {
736 unsigned int return_stack;
737
738 if (sscanf(buf, "%u", &return_stack) != 1)
739 return -EINVAL;
740
741 mutex_lock(&tracer.mutex);
742 if (return_stack) {
743 tracer.flags |= TRACER_RETURN_STACK;
744 /* Return stack is incompatible with branch broadcasting */
745 tracer.flags &= ~TRACER_BRANCHOUTPUT;
746 } else {
747 tracer.flags &= ~TRACER_RETURN_STACK;
748 }
749 mutex_unlock(&tracer.mutex);
750
751 return n;
752 }
753
754 static struct kobj_attribute trace_return_stack_attr =
755 __ATTR(trace_return_stack, 0644,
756 trace_return_stack_show, trace_return_stack_store);
757
758 static ssize_t trace_timestamp_show(struct kobject *kobj,
759 struct kobj_attribute *attr,
760 char *buf)
761 {
762 return sprintf(buf, "%d\n", !!(tracer.flags & TRACER_TIMESTAMP));
763 }
764
765 static ssize_t trace_timestamp_store(struct kobject *kobj,
766 struct kobj_attribute *attr,
767 const char *buf, size_t n)
768 {
769 unsigned int timestamp;
770
771 if (sscanf(buf, "%u", &timestamp) != 1)
772 return -EINVAL;
773
774 mutex_lock(&tracer.mutex);
775 if (timestamp)
776 tracer.flags |= TRACER_TIMESTAMP;
777 else
778 tracer.flags &= ~TRACER_TIMESTAMP;
779 mutex_unlock(&tracer.mutex);
780
781 return n;
782 }
783
784 static struct kobj_attribute trace_timestamp_attr =
785 __ATTR(trace_timestamp, 0644,
786 trace_timestamp_show, trace_timestamp_store);
787
788 static ssize_t trace_range_show(struct kobject *kobj,
789 struct kobj_attribute *attr,
790 char *buf)
791 {
792 return sprintf(buf, "%08lx %08lx\n",
793 tracer.range_start, tracer.range_end);
794 }
795
796 static ssize_t trace_range_store(struct kobject *kobj,
797 struct kobj_attribute *attr,
798 const char *buf, size_t n)
799 {
800 unsigned long range_start, range_end;
801
802 if (sscanf(buf, "%lx %lx", &range_start, &range_end) != 2)
803 return -EINVAL;
804
805 mutex_lock(&tracer.mutex);
806 tracer.range_start = range_start;
807 tracer.range_end = range_end;
808 mutex_unlock(&tracer.mutex);
809
810 return n;
811 }
812
813
814 static struct kobj_attribute trace_range_attr =
815 __ATTR(trace_range, 0644, trace_range_show, trace_range_store);
816
817 static ssize_t trace_data_range_show(struct kobject *kobj,
818 struct kobj_attribute *attr,
819 char *buf)
820 {
821 unsigned long range_start;
822 u64 range_end;
823 mutex_lock(&tracer.mutex);
824 range_start = tracer.data_range_start;
825 range_end = tracer.data_range_end;
826 if (!range_end && (tracer.flags & TRACER_TRACE_DATA))
827 range_end = 0x100000000ULL;
828 mutex_unlock(&tracer.mutex);
829 return sprintf(buf, "%08lx %08llx\n", range_start, range_end);
830 }
831
832 static ssize_t trace_data_range_store(struct kobject *kobj,
833 struct kobj_attribute *attr,
834 const char *buf, size_t n)
835 {
836 unsigned long range_start;
837 u64 range_end;
838
839 if (sscanf(buf, "%lx %llx", &range_start, &range_end) != 2)
840 return -EINVAL;
841
842 mutex_lock(&tracer.mutex);
843 tracer.data_range_start = range_start;
844 tracer.data_range_end = (unsigned long)range_end;
845 if (range_end)
846 tracer.flags |= TRACER_TRACE_DATA;
847 else
848 tracer.flags &= ~TRACER_TRACE_DATA;
849 mutex_unlock(&tracer.mutex);
850
851 return n;
852 }
853
854
855 static struct kobj_attribute trace_data_range_attr =
856 __ATTR(trace_data_range, 0644,
857 trace_data_range_show, trace_data_range_store);
858
859 static int etm_probe(struct amba_device *dev, const struct amba_id *id)
860 {
861 struct tracectx *t = &tracer;
862 int ret = 0;
863 void __iomem **new_regs;
864 int new_count;
865 u32 etmccr;
866 u32 etmidr;
867 u32 etmccer = 0;
868 u8 etm_version = 0;
869
870 mutex_lock(&t->mutex);
871 new_count = t->etm_regs_count + 1;
872 new_regs = krealloc(t->etm_regs,
873 sizeof(t->etm_regs[0]) * new_count, GFP_KERNEL);
874
875 if (!new_regs) {
876 dev_dbg(&dev->dev, "Failed to allocate ETM register array\n");
877 ret = -ENOMEM;
878 goto out;
879 }
880 t->etm_regs = new_regs;
881
882 ret = amba_request_regions(dev, NULL);
883 if (ret)
884 goto out;
885
886 t->etm_regs[t->etm_regs_count] =
887 ioremap_nocache(dev->res.start, resource_size(&dev->res));
888 if (!t->etm_regs[t->etm_regs_count]) {
889 ret = -ENOMEM;
890 goto out_release;
891 }
892
893 amba_set_drvdata(dev, t->etm_regs[t->etm_regs_count]);
894
895 t->flags = TRACER_CYCLE_ACC | TRACER_TRACE_DATA | TRACER_BRANCHOUTPUT;
896 t->etm_portsz = 1;
897 t->etm_contextid_size = 3;
898
899 etm_unlock(t, t->etm_regs_count);
900 (void)etm_readl(t, t->etm_regs_count, ETMMR_PDSR);
901 /* dummy first read */
902 (void)etm_readl(&tracer, t->etm_regs_count, ETMMR_OSSRR);
903
904 etmccr = etm_readl(t, t->etm_regs_count, ETMR_CONFCODE);
905 t->ncmppairs = etmccr & 0xf;
906 if (etmccr & ETMCCR_ETMIDR_PRESENT) {
907 etmidr = etm_readl(t, t->etm_regs_count, ETMR_ID);
908 etm_version = ETMIDR_VERSION(etmidr);
909 if (etm_version >= ETMIDR_VERSION_3_1)
910 etmccer = etm_readl(t, t->etm_regs_count, ETMR_CCE);
911 }
912 etm_writel(t, t->etm_regs_count, 0x441, ETMR_CTRL);
913 etm_writel(t, t->etm_regs_count, new_count, ETMR_TRACEIDR);
914 etm_lock(t, t->etm_regs_count);
915
916 ret = sysfs_create_file(&dev->dev.kobj,
917 &trace_running_attr.attr);
918 if (ret)
919 goto out_unmap;
920
921 /* failing to create any of these two is not fatal */
922 ret = sysfs_create_file(&dev->dev.kobj, &trace_info_attr.attr);
923 if (ret)
924 dev_dbg(&dev->dev, "Failed to create trace_info in sysfs\n");
925
926 ret = sysfs_create_file(&dev->dev.kobj, &trace_mode_attr.attr);
927 if (ret)
928 dev_dbg(&dev->dev, "Failed to create trace_mode in sysfs\n");
929
930 ret = sysfs_create_file(&dev->dev.kobj,
931 &trace_contextid_size_attr.attr);
932 if (ret)
933 dev_dbg(&dev->dev,
934 "Failed to create trace_contextid_size in sysfs\n");
935
936 ret = sysfs_create_file(&dev->dev.kobj,
937 &trace_branch_output_attr.attr);
938 if (ret)
939 dev_dbg(&dev->dev,
940 "Failed to create trace_branch_output in sysfs\n");
941
942 if (etmccer & ETMCCER_RETURN_STACK_IMPLEMENTED) {
943 ret = sysfs_create_file(&dev->dev.kobj,
944 &trace_return_stack_attr.attr);
945 if (ret)
946 dev_dbg(&dev->dev,
947 "Failed to create trace_return_stack in sysfs\n");
948 }
949
950 if (etmccer & ETMCCER_TIMESTAMPING_IMPLEMENTED) {
951 ret = sysfs_create_file(&dev->dev.kobj,
952 &trace_timestamp_attr.attr);
953 if (ret)
954 dev_dbg(&dev->dev,
955 "Failed to create trace_timestamp in sysfs\n");
956 }
957
958 ret = sysfs_create_file(&dev->dev.kobj, &trace_range_attr.attr);
959 if (ret)
960 dev_dbg(&dev->dev, "Failed to create trace_range in sysfs\n");
961
962 if (etm_version < ETMIDR_VERSION_PFT_1_0) {
963 ret = sysfs_create_file(&dev->dev.kobj,
964 &trace_data_range_attr.attr);
965 if (ret)
966 dev_dbg(&dev->dev,
967 "Failed to create trace_data_range in sysfs\n");
968 } else {
969 tracer.flags &= ~TRACER_TRACE_DATA;
970 }
971
972 dev_dbg(&dev->dev, "ETM AMBA driver initialized.\n");
973
974 /* Enable formatter if there are multiple trace sources */
975 if (new_count > 1)
976 t->etb_fc = ETBFF_ENFCONT | ETBFF_ENFTC;
977
978 t->etm_regs_count = new_count;
979
980 out:
981 mutex_unlock(&t->mutex);
982 return ret;
983
984 out_unmap:
985 amba_set_drvdata(dev, NULL);
986 iounmap(t->etm_regs[t->etm_regs_count]);
987
988 out_release:
989 amba_release_regions(dev);
990
991 mutex_unlock(&t->mutex);
992 return ret;
993 }
994
995 static int etm_remove(struct amba_device *dev)
996 {
997 int i;
998 struct tracectx *t = &tracer;
999 void __iomem *etm_regs = amba_get_drvdata(dev);
1000
1001 sysfs_remove_file(&dev->dev.kobj, &trace_running_attr.attr);
1002 sysfs_remove_file(&dev->dev.kobj, &trace_info_attr.attr);
1003 sysfs_remove_file(&dev->dev.kobj, &trace_mode_attr.attr);
1004 sysfs_remove_file(&dev->dev.kobj, &trace_range_attr.attr);
1005 sysfs_remove_file(&dev->dev.kobj, &trace_data_range_attr.attr);
1006
1007 amba_set_drvdata(dev, NULL);
1008
1009 mutex_lock(&t->mutex);
1010 for (i = 0; i < t->etm_regs_count; i++)
1011 if (t->etm_regs[i] == etm_regs)
1012 break;
1013 for (; i < t->etm_regs_count - 1; i++)
1014 t->etm_regs[i] = t->etm_regs[i + 1];
1015 t->etm_regs_count--;
1016 if (!t->etm_regs_count) {
1017 kfree(t->etm_regs);
1018 t->etm_regs = NULL;
1019 }
1020 mutex_unlock(&t->mutex);
1021
1022 iounmap(etm_regs);
1023 amba_release_regions(dev);
1024
1025 return 0;
1026 }
1027
1028 static struct amba_id etm_ids[] = {
1029 {
1030 .id = 0x0003b921,
1031 .mask = 0x0007ffff,
1032 },
1033 {
1034 .id = 0x0003b950,
1035 .mask = 0x0007ffff,
1036 },
1037 { 0, 0 },
1038 };
1039
1040 static struct amba_driver etm_driver = {
1041 .drv = {
1042 .name = "etm",
1043 .owner = THIS_MODULE,
1044 },
1045 .probe = etm_probe,
1046 .remove = etm_remove,
1047 .id_table = etm_ids,
1048 };
1049
1050 static int __init etm_init(void)
1051 {
1052 int retval;
1053
1054 mutex_init(&tracer.mutex);
1055
1056 retval = amba_driver_register(&etb_driver);
1057 if (retval) {
1058 printk(KERN_ERR "Failed to register etb\n");
1059 return retval;
1060 }
1061
1062 retval = amba_driver_register(&etm_driver);
1063 if (retval) {
1064 amba_driver_unregister(&etb_driver);
1065 printk(KERN_ERR "Failed to probe etm\n");
1066 return retval;
1067 }
1068
1069 /* not being able to install this handler is not fatal */
1070 (void)register_sysrq_key('v', &sysrq_etm_op);
1071
1072 return 0;
1073 }
1074
1075 device_initcall(etm_init);
1076
kernel source for telekom puls (alcatel/mediatek)