ARM: use linker magic for vectors and vector stubs
[linux-3.10.git] / arch / arm / kernel / hw_breakpoint.c
1 /*
2  * This program is free software; you can redistribute it and/or modify
3  * it under the terms of the GNU General Public License version 2 as
4  * published by the Free Software Foundation.
5  *
6  * This program is distributed in the hope that it will be useful,
7  * but WITHOUT ANY WARRANTY; without even the implied warranty of
8  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
9  * GNU General Public License for more details.
10  *
11  * You should have received a copy of the GNU General Public License
12  * along with this program; if not, write to the Free Software
13  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
14  *
15  * Copyright (C) 2009, 2010 ARM Limited
16  *
17  * Author: Will Deacon <will.deacon@arm.com>
18  */
19
20 /*
21  * HW_breakpoint: a unified kernel/user-space hardware breakpoint facility,
22  * using the CPU's debug registers.
23  */
24 #define pr_fmt(fmt) "hw-breakpoint: " fmt
25
26 #include <linux/errno.h>
27 #include <linux/hardirq.h>
28 #include <linux/perf_event.h>
29 #include <linux/hw_breakpoint.h>
30 #include <linux/smp.h>
31 #include <linux/cpu_pm.h>
32
33 #include <asm/cacheflush.h>
34 #include <asm/cputype.h>
35 #include <asm/current.h>
36 #include <asm/hw_breakpoint.h>
37 #include <asm/kdebug.h>
38 #include <asm/traps.h>
39 #include <asm/hardware/coresight.h>
40
41 /* Breakpoint currently in use for each BRP. */
42 static DEFINE_PER_CPU(struct perf_event *, bp_on_reg[ARM_MAX_BRP]);
43
44 /* Watchpoint currently in use for each WRP. */
45 static DEFINE_PER_CPU(struct perf_event *, wp_on_reg[ARM_MAX_WRP]);
46
47 /* Number of BRP/WRP registers on this CPU. */
48 static int core_num_brps;
49 static int core_num_wrps;
50
51 /* Debug architecture version. */
52 static u8 debug_arch;
53
54 /* Does debug architecture support OS Save and Restore? */
55 static bool has_ossr;
56
57 /* Maximum supported watchpoint length. */
58 static u8 max_watchpoint_len;
59
60 #define READ_WB_REG_CASE(OP2, M, VAL)                   \
61         case ((OP2 << 4) + M):                          \
62                 ARM_DBG_READ(c0, c ## M, OP2, VAL);     \
63                 break
64
65 #define WRITE_WB_REG_CASE(OP2, M, VAL)                  \
66         case ((OP2 << 4) + M):                          \
67                 ARM_DBG_WRITE(c0, c ## M, OP2, VAL);    \
68                 break
69
70 #define GEN_READ_WB_REG_CASES(OP2, VAL)         \
71         READ_WB_REG_CASE(OP2, 0, VAL);          \
72         READ_WB_REG_CASE(OP2, 1, VAL);          \
73         READ_WB_REG_CASE(OP2, 2, VAL);          \
74         READ_WB_REG_CASE(OP2, 3, VAL);          \
75         READ_WB_REG_CASE(OP2, 4, VAL);          \
76         READ_WB_REG_CASE(OP2, 5, VAL);          \
77         READ_WB_REG_CASE(OP2, 6, VAL);          \
78         READ_WB_REG_CASE(OP2, 7, VAL);          \
79         READ_WB_REG_CASE(OP2, 8, VAL);          \
80         READ_WB_REG_CASE(OP2, 9, VAL);          \
81         READ_WB_REG_CASE(OP2, 10, VAL);         \
82         READ_WB_REG_CASE(OP2, 11, VAL);         \
83         READ_WB_REG_CASE(OP2, 12, VAL);         \
84         READ_WB_REG_CASE(OP2, 13, VAL);         \
85         READ_WB_REG_CASE(OP2, 14, VAL);         \
86         READ_WB_REG_CASE(OP2, 15, VAL)
87
88 #define GEN_WRITE_WB_REG_CASES(OP2, VAL)        \
89         WRITE_WB_REG_CASE(OP2, 0, VAL);         \
90         WRITE_WB_REG_CASE(OP2, 1, VAL);         \
91         WRITE_WB_REG_CASE(OP2, 2, VAL);         \
92         WRITE_WB_REG_CASE(OP2, 3, VAL);         \
93         WRITE_WB_REG_CASE(OP2, 4, VAL);         \
94         WRITE_WB_REG_CASE(OP2, 5, VAL);         \
95         WRITE_WB_REG_CASE(OP2, 6, VAL);         \
96         WRITE_WB_REG_CASE(OP2, 7, VAL);         \
97         WRITE_WB_REG_CASE(OP2, 8, VAL);         \
98         WRITE_WB_REG_CASE(OP2, 9, VAL);         \
99         WRITE_WB_REG_CASE(OP2, 10, VAL);        \
100         WRITE_WB_REG_CASE(OP2, 11, VAL);        \
101         WRITE_WB_REG_CASE(OP2, 12, VAL);        \
102         WRITE_WB_REG_CASE(OP2, 13, VAL);        \
103         WRITE_WB_REG_CASE(OP2, 14, VAL);        \
104         WRITE_WB_REG_CASE(OP2, 15, VAL)
105
106 static u32 read_wb_reg(int n)
107 {
108         u32 val = 0;
109
110         switch (n) {
111         GEN_READ_WB_REG_CASES(ARM_OP2_BVR, val);
112         GEN_READ_WB_REG_CASES(ARM_OP2_BCR, val);
113         GEN_READ_WB_REG_CASES(ARM_OP2_WVR, val);
114         GEN_READ_WB_REG_CASES(ARM_OP2_WCR, val);
115         default:
116                 pr_warning("attempt to read from unknown breakpoint "
117                                 "register %d\n", n);
118         }
119
120         return val;
121 }
122
123 static void write_wb_reg(int n, u32 val)
124 {
125         switch (n) {
126         GEN_WRITE_WB_REG_CASES(ARM_OP2_BVR, val);
127         GEN_WRITE_WB_REG_CASES(ARM_OP2_BCR, val);
128         GEN_WRITE_WB_REG_CASES(ARM_OP2_WVR, val);
129         GEN_WRITE_WB_REG_CASES(ARM_OP2_WCR, val);
130         default:
131                 pr_warning("attempt to write to unknown breakpoint "
132                                 "register %d\n", n);
133         }
134         isb();
135 }
136
137 /* Determine debug architecture. */
138 static u8 get_debug_arch(void)
139 {
140         u32 didr;
141
142         /* Do we implement the extended CPUID interface? */
143         if (((read_cpuid_id() >> 16) & 0xf) != 0xf) {
144                 pr_warn_once("CPUID feature registers not supported. "
145                              "Assuming v6 debug is present.\n");
146                 return ARM_DEBUG_ARCH_V6;
147         }
148
149         ARM_DBG_READ(c0, c0, 0, didr);
150         return (didr >> 16) & 0xf;
151 }
152
153 u8 arch_get_debug_arch(void)
154 {
155         return debug_arch;
156 }
157
158 static int debug_arch_supported(void)
159 {
160         u8 arch = get_debug_arch();
161
162         /* We don't support the memory-mapped interface. */
163         return (arch >= ARM_DEBUG_ARCH_V6 && arch <= ARM_DEBUG_ARCH_V7_ECP14) ||
164                 arch >= ARM_DEBUG_ARCH_V7_1;
165 }
166
167 /* Can we determine the watchpoint access type from the fsr? */
168 static int debug_exception_updates_fsr(void)
169 {
170         return 0;
171 }
172
173 /* Determine number of WRP registers available. */
174 static int get_num_wrp_resources(void)
175 {
176         u32 didr;
177         ARM_DBG_READ(c0, c0, 0, didr);
178         return ((didr >> 28) & 0xf) + 1;
179 }
180
181 /* Determine number of BRP registers available. */
182 static int get_num_brp_resources(void)
183 {
184         u32 didr;
185         ARM_DBG_READ(c0, c0, 0, didr);
186         return ((didr >> 24) & 0xf) + 1;
187 }
188
189 /* Does this core support mismatch breakpoints? */
190 static int core_has_mismatch_brps(void)
191 {
192         return (get_debug_arch() >= ARM_DEBUG_ARCH_V7_ECP14 &&
193                 get_num_brp_resources() > 1);
194 }
195
196 /* Determine number of usable WRPs available. */
197 static int get_num_wrps(void)
198 {
199         /*
200          * On debug architectures prior to 7.1, when a watchpoint fires, the
201          * only way to work out which watchpoint it was is by disassembling
202          * the faulting instruction and working out the address of the memory
203          * access.
204          *
205          * Furthermore, we can only do this if the watchpoint was precise
206          * since imprecise watchpoints prevent us from calculating register
207          * based addresses.
208          *
209          * Providing we have more than 1 breakpoint register, we only report
210          * a single watchpoint register for the time being. This way, we always
211          * know which watchpoint fired. In the future we can either add a
212          * disassembler and address generation emulator, or we can insert a
213          * check to see if the DFAR is set on watchpoint exception entry
214          * [the ARM ARM states that the DFAR is UNKNOWN, but experience shows
215          * that it is set on some implementations].
216          */
217         if (get_debug_arch() < ARM_DEBUG_ARCH_V7_1)
218                 return 1;
219
220         return get_num_wrp_resources();
221 }
222
223 /* Determine number of usable BRPs available. */
224 static int get_num_brps(void)
225 {
226         int brps = get_num_brp_resources();
227         return core_has_mismatch_brps() ? brps - 1 : brps;
228 }
229
230 /*
231  * In order to access the breakpoint/watchpoint control registers,
232  * we must be running in debug monitor mode. Unfortunately, we can
233  * be put into halting debug mode at any time by an external debugger
234  * but there is nothing we can do to prevent that.
235  */
236 static int monitor_mode_enabled(void)
237 {
238         u32 dscr;
239         ARM_DBG_READ(c0, c1, 0, dscr);
240         return !!(dscr & ARM_DSCR_MDBGEN);
241 }
242
243 static int enable_monitor_mode(void)
244 {
245         u32 dscr;
246         ARM_DBG_READ(c0, c1, 0, dscr);
247
248         /* If monitor mode is already enabled, just return. */
249         if (dscr & ARM_DSCR_MDBGEN)
250                 goto out;
251
252         /* Write to the corresponding DSCR. */
253         switch (get_debug_arch()) {
254         case ARM_DEBUG_ARCH_V6:
255         case ARM_DEBUG_ARCH_V6_1:
256                 ARM_DBG_WRITE(c0, c1, 0, (dscr | ARM_DSCR_MDBGEN));
257                 break;
258         case ARM_DEBUG_ARCH_V7_ECP14:
259         case ARM_DEBUG_ARCH_V7_1:
260                 ARM_DBG_WRITE(c0, c2, 2, (dscr | ARM_DSCR_MDBGEN));
261                 isb();
262                 break;
263         default:
264                 return -ENODEV;
265         }
266
267         /* Check that the write made it through. */
268         ARM_DBG_READ(c0, c1, 0, dscr);
269         if (!(dscr & ARM_DSCR_MDBGEN)) {
270                 pr_warn_once("Failed to enable monitor mode on CPU %d.\n",
271                                 smp_processor_id());
272                 return -EPERM;
273         }
274
275 out:
276         return 0;
277 }
278
279 int hw_breakpoint_slots(int type)
280 {
281         if (!debug_arch_supported())
282                 return 0;
283
284         /*
285          * We can be called early, so don't rely on
286          * our static variables being initialised.
287          */
288         switch (type) {
289         case TYPE_INST:
290                 return get_num_brps();
291         case TYPE_DATA:
292                 return get_num_wrps();
293         default:
294                 pr_warning("unknown slot type: %d\n", type);
295                 return 0;
296         }
297 }
298
299 /*
300  * Check if 8-bit byte-address select is available.
301  * This clobbers WRP 0.
302  */
303 static u8 get_max_wp_len(void)
304 {
305         u32 ctrl_reg;
306         struct arch_hw_breakpoint_ctrl ctrl;
307         u8 size = 4;
308
309         if (debug_arch < ARM_DEBUG_ARCH_V7_ECP14)
310                 goto out;
311
312         memset(&ctrl, 0, sizeof(ctrl));
313         ctrl.len = ARM_BREAKPOINT_LEN_8;
314         ctrl_reg = encode_ctrl_reg(ctrl);
315
316         write_wb_reg(ARM_BASE_WVR, 0);
317         write_wb_reg(ARM_BASE_WCR, ctrl_reg);
318         if ((read_wb_reg(ARM_BASE_WCR) & ctrl_reg) == ctrl_reg)
319                 size = 8;
320
321 out:
322         return size;
323 }
324
325 u8 arch_get_max_wp_len(void)
326 {
327         return max_watchpoint_len;
328 }
329
330 /*
331  * Install a perf counter breakpoint.
332  */
333 int arch_install_hw_breakpoint(struct perf_event *bp)
334 {
335         struct arch_hw_breakpoint *info = counter_arch_bp(bp);
336         struct perf_event **slot, **slots;
337         int i, max_slots, ctrl_base, val_base;
338         u32 addr, ctrl;
339
340         addr = info->address;
341         ctrl = encode_ctrl_reg(info->ctrl) | 0x1;
342
343         if (info->ctrl.type == ARM_BREAKPOINT_EXECUTE) {
344                 /* Breakpoint */
345                 ctrl_base = ARM_BASE_BCR;
346                 val_base = ARM_BASE_BVR;
347                 slots = (struct perf_event **)__get_cpu_var(bp_on_reg);
348                 max_slots = core_num_brps;
349         } else {
350                 /* Watchpoint */
351                 ctrl_base = ARM_BASE_WCR;
352                 val_base = ARM_BASE_WVR;
353                 slots = (struct perf_event **)__get_cpu_var(wp_on_reg);
354                 max_slots = core_num_wrps;
355         }
356
357         for (i = 0; i < max_slots; ++i) {
358                 slot = &slots[i];
359
360                 if (!*slot) {
361                         *slot = bp;
362                         break;
363                 }
364         }
365
366         if (i == max_slots) {
367                 pr_warning("Can't find any breakpoint slot\n");
368                 return -EBUSY;
369         }
370
371         /* Override the breakpoint data with the step data. */
372         if (info->step_ctrl.enabled) {
373                 addr = info->trigger & ~0x3;
374                 ctrl = encode_ctrl_reg(info->step_ctrl);
375                 if (info->ctrl.type != ARM_BREAKPOINT_EXECUTE) {
376                         i = 0;
377                         ctrl_base = ARM_BASE_BCR + core_num_brps;
378                         val_base = ARM_BASE_BVR + core_num_brps;
379                 }
380         }
381
382         /* Setup the address register. */
383         write_wb_reg(val_base + i, addr);
384
385         /* Setup the control register. */
386         write_wb_reg(ctrl_base + i, ctrl);
387         return 0;
388 }
389
390 void arch_uninstall_hw_breakpoint(struct perf_event *bp)
391 {
392         struct arch_hw_breakpoint *info = counter_arch_bp(bp);
393         struct perf_event **slot, **slots;
394         int i, max_slots, base;
395
396         if (info->ctrl.type == ARM_BREAKPOINT_EXECUTE) {
397                 /* Breakpoint */
398                 base = ARM_BASE_BCR;
399                 slots = (struct perf_event **)__get_cpu_var(bp_on_reg);
400                 max_slots = core_num_brps;
401         } else {
402                 /* Watchpoint */
403                 base = ARM_BASE_WCR;
404                 slots = (struct perf_event **)__get_cpu_var(wp_on_reg);
405                 max_slots = core_num_wrps;
406         }
407
408         /* Remove the breakpoint. */
409         for (i = 0; i < max_slots; ++i) {
410                 slot = &slots[i];
411
412                 if (*slot == bp) {
413                         *slot = NULL;
414                         break;
415                 }
416         }
417
418         if (i == max_slots) {
419                 pr_warning("Can't find any breakpoint slot\n");
420                 return;
421         }
422
423         /* Ensure that we disable the mismatch breakpoint. */
424         if (info->ctrl.type != ARM_BREAKPOINT_EXECUTE &&
425             info->step_ctrl.enabled) {
426                 i = 0;
427                 base = ARM_BASE_BCR + core_num_brps;
428         }
429
430         /* Reset the control register. */
431         write_wb_reg(base + i, 0);
432 }
433
434 static int get_hbp_len(u8 hbp_len)
435 {
436         unsigned int len_in_bytes = 0;
437
438         switch (hbp_len) {
439         case ARM_BREAKPOINT_LEN_1:
440                 len_in_bytes = 1;
441                 break;
442         case ARM_BREAKPOINT_LEN_2:
443                 len_in_bytes = 2;
444                 break;
445         case ARM_BREAKPOINT_LEN_4:
446                 len_in_bytes = 4;
447                 break;
448         case ARM_BREAKPOINT_LEN_8:
449                 len_in_bytes = 8;
450                 break;
451         }
452
453         return len_in_bytes;
454 }
455
456 /*
457  * Check whether bp virtual address is in kernel space.
458  */
459 int arch_check_bp_in_kernelspace(struct perf_event *bp)
460 {
461         unsigned int len;
462         unsigned long va;
463         struct arch_hw_breakpoint *info = counter_arch_bp(bp);
464
465         va = info->address;
466         len = get_hbp_len(info->ctrl.len);
467
468         return (va >= TASK_SIZE) && ((va + len - 1) >= TASK_SIZE);
469 }
470
471 /*
472  * Extract generic type and length encodings from an arch_hw_breakpoint_ctrl.
473  * Hopefully this will disappear when ptrace can bypass the conversion
474  * to generic breakpoint descriptions.
475  */
476 int arch_bp_generic_fields(struct arch_hw_breakpoint_ctrl ctrl,
477                            int *gen_len, int *gen_type)
478 {
479         /* Type */
480         switch (ctrl.type) {
481         case ARM_BREAKPOINT_EXECUTE:
482                 *gen_type = HW_BREAKPOINT_X;
483                 break;
484         case ARM_BREAKPOINT_LOAD:
485                 *gen_type = HW_BREAKPOINT_R;
486                 break;
487         case ARM_BREAKPOINT_STORE:
488                 *gen_type = HW_BREAKPOINT_W;
489                 break;
490         case ARM_BREAKPOINT_LOAD | ARM_BREAKPOINT_STORE:
491                 *gen_type = HW_BREAKPOINT_RW;
492                 break;
493         default:
494                 return -EINVAL;
495         }
496
497         /* Len */
498         switch (ctrl.len) {
499         case ARM_BREAKPOINT_LEN_1:
500                 *gen_len = HW_BREAKPOINT_LEN_1;
501                 break;
502         case ARM_BREAKPOINT_LEN_2:
503                 *gen_len = HW_BREAKPOINT_LEN_2;
504                 break;
505         case ARM_BREAKPOINT_LEN_4:
506                 *gen_len = HW_BREAKPOINT_LEN_4;
507                 break;
508         case ARM_BREAKPOINT_LEN_8:
509                 *gen_len = HW_BREAKPOINT_LEN_8;
510                 break;
511         default:
512                 return -EINVAL;
513         }
514
515         return 0;
516 }
517
518 /*
519  * Construct an arch_hw_breakpoint from a perf_event.
520  */
521 static int arch_build_bp_info(struct perf_event *bp)
522 {
523         struct arch_hw_breakpoint *info = counter_arch_bp(bp);
524
525         /* Type */
526         switch (bp->attr.bp_type) {
527         case HW_BREAKPOINT_X:
528                 info->ctrl.type = ARM_BREAKPOINT_EXECUTE;
529                 break;
530         case HW_BREAKPOINT_R:
531                 info->ctrl.type = ARM_BREAKPOINT_LOAD;
532                 break;
533         case HW_BREAKPOINT_W:
534                 info->ctrl.type = ARM_BREAKPOINT_STORE;
535                 break;
536         case HW_BREAKPOINT_RW:
537                 info->ctrl.type = ARM_BREAKPOINT_LOAD | ARM_BREAKPOINT_STORE;
538                 break;
539         default:
540                 return -EINVAL;
541         }
542
543         /* Len */
544         switch (bp->attr.bp_len) {
545         case HW_BREAKPOINT_LEN_1:
546                 info->ctrl.len = ARM_BREAKPOINT_LEN_1;
547                 break;
548         case HW_BREAKPOINT_LEN_2:
549                 info->ctrl.len = ARM_BREAKPOINT_LEN_2;
550                 break;
551         case HW_BREAKPOINT_LEN_4:
552                 info->ctrl.len = ARM_BREAKPOINT_LEN_4;
553                 break;
554         case HW_BREAKPOINT_LEN_8:
555                 info->ctrl.len = ARM_BREAKPOINT_LEN_8;
556                 if ((info->ctrl.type != ARM_BREAKPOINT_EXECUTE)
557                         && max_watchpoint_len >= 8)
558                         break;
559         default:
560                 return -EINVAL;
561         }
562
563         /*
564          * Breakpoints must be of length 2 (thumb) or 4 (ARM) bytes.
565          * Watchpoints can be of length 1, 2, 4 or 8 bytes if supported
566          * by the hardware and must be aligned to the appropriate number of
567          * bytes.
568          */
569         if (info->ctrl.type == ARM_BREAKPOINT_EXECUTE &&
570             info->ctrl.len != ARM_BREAKPOINT_LEN_2 &&
571             info->ctrl.len != ARM_BREAKPOINT_LEN_4)
572                 return -EINVAL;
573
574         /* Address */
575         info->address = bp->attr.bp_addr;
576
577         /* Privilege */
578         info->ctrl.privilege = ARM_BREAKPOINT_USER;
579         if (arch_check_bp_in_kernelspace(bp))
580                 info->ctrl.privilege |= ARM_BREAKPOINT_PRIV;
581
582         /* Enabled? */
583         info->ctrl.enabled = !bp->attr.disabled;
584
585         /* Mismatch */
586         info->ctrl.mismatch = 0;
587
588         return 0;
589 }
590
591 /*
592  * Validate the arch-specific HW Breakpoint register settings.
593  */
594 int arch_validate_hwbkpt_settings(struct perf_event *bp)
595 {
596         struct arch_hw_breakpoint *info = counter_arch_bp(bp);
597         int ret = 0;
598         u32 offset, alignment_mask = 0x3;
599
600         /* Ensure that we are in monitor debug mode. */
601         if (!monitor_mode_enabled())
602                 return -ENODEV;
603
604         /* Build the arch_hw_breakpoint. */
605         ret = arch_build_bp_info(bp);
606         if (ret)
607                 goto out;
608
609         /* Check address alignment. */
610         if (info->ctrl.len == ARM_BREAKPOINT_LEN_8)
611                 alignment_mask = 0x7;
612         offset = info->address & alignment_mask;
613         switch (offset) {
614         case 0:
615                 /* Aligned */
616                 break;
617         case 1:
618         case 2:
619                 /* Allow halfword watchpoints and breakpoints. */
620                 if (info->ctrl.len == ARM_BREAKPOINT_LEN_2)
621                         break;
622         case 3:
623                 /* Allow single byte watchpoint. */
624                 if (info->ctrl.len == ARM_BREAKPOINT_LEN_1)
625                         break;
626         default:
627                 ret = -EINVAL;
628                 goto out;
629         }
630
631         info->address &= ~alignment_mask;
632         info->ctrl.len <<= offset;
633
634         if (!bp->overflow_handler) {
635                 /*
636                  * Mismatch breakpoints are required for single-stepping
637                  * breakpoints.
638                  */
639                 if (!core_has_mismatch_brps())
640                         return -EINVAL;
641
642                 /* We don't allow mismatch breakpoints in kernel space. */
643                 if (arch_check_bp_in_kernelspace(bp))
644                         return -EPERM;
645
646                 /*
647                  * Per-cpu breakpoints are not supported by our stepping
648                  * mechanism.
649                  */
650                 if (!bp->hw.bp_target)
651                         return -EINVAL;
652
653                 /*
654                  * We only support specific access types if the fsr
655                  * reports them.
656                  */
657                 if (!debug_exception_updates_fsr() &&
658                     (info->ctrl.type == ARM_BREAKPOINT_LOAD ||
659                      info->ctrl.type == ARM_BREAKPOINT_STORE))
660                         return -EINVAL;
661         }
662
663 out:
664         return ret;
665 }
666
667 /*
668  * Enable/disable single-stepping over the breakpoint bp at address addr.
669  */
670 static void enable_single_step(struct perf_event *bp, u32 addr)
671 {
672         struct arch_hw_breakpoint *info = counter_arch_bp(bp);
673
674         arch_uninstall_hw_breakpoint(bp);
675         info->step_ctrl.mismatch  = 1;
676         info->step_ctrl.len       = ARM_BREAKPOINT_LEN_4;
677         info->step_ctrl.type      = ARM_BREAKPOINT_EXECUTE;
678         info->step_ctrl.privilege = info->ctrl.privilege;
679         info->step_ctrl.enabled   = 1;
680         info->trigger             = addr;
681         arch_install_hw_breakpoint(bp);
682 }
683
684 static void disable_single_step(struct perf_event *bp)
685 {
686         arch_uninstall_hw_breakpoint(bp);
687         counter_arch_bp(bp)->step_ctrl.enabled = 0;
688         arch_install_hw_breakpoint(bp);
689 }
690
691 static void watchpoint_handler(unsigned long addr, unsigned int fsr,
692                                struct pt_regs *regs)
693 {
694         int i, access;
695         u32 val, ctrl_reg, alignment_mask;
696         struct perf_event *wp, **slots;
697         struct arch_hw_breakpoint *info;
698         struct arch_hw_breakpoint_ctrl ctrl;
699
700         slots = (struct perf_event **)__get_cpu_var(wp_on_reg);
701
702         for (i = 0; i < core_num_wrps; ++i) {
703                 rcu_read_lock();
704
705                 wp = slots[i];
706
707                 if (wp == NULL)
708                         goto unlock;
709
710                 info = counter_arch_bp(wp);
711                 /*
712                  * The DFAR is an unknown value on debug architectures prior
713                  * to 7.1. Since we only allow a single watchpoint on these
714                  * older CPUs, we can set the trigger to the lowest possible
715                  * faulting address.
716                  */
717                 if (debug_arch < ARM_DEBUG_ARCH_V7_1) {
718                         BUG_ON(i > 0);
719                         info->trigger = wp->attr.bp_addr;
720                 } else {
721                         if (info->ctrl.len == ARM_BREAKPOINT_LEN_8)
722                                 alignment_mask = 0x7;
723                         else
724                                 alignment_mask = 0x3;
725
726                         /* Check if the watchpoint value matches. */
727                         val = read_wb_reg(ARM_BASE_WVR + i);
728                         if (val != (addr & ~alignment_mask))
729                                 goto unlock;
730
731                         /* Possible match, check the byte address select. */
732                         ctrl_reg = read_wb_reg(ARM_BASE_WCR + i);
733                         decode_ctrl_reg(ctrl_reg, &ctrl);
734                         if (!((1 << (addr & alignment_mask)) & ctrl.len))
735                                 goto unlock;
736
737                         /* Check that the access type matches. */
738                         if (debug_exception_updates_fsr()) {
739                                 access = (fsr & ARM_FSR_ACCESS_MASK) ?
740                                           HW_BREAKPOINT_W : HW_BREAKPOINT_R;
741                                 if (!(access & hw_breakpoint_type(wp)))
742                                         goto unlock;
743                         }
744
745                         /* We have a winner. */
746                         info->trigger = addr;
747                 }
748
749                 pr_debug("watchpoint fired: address = 0x%x\n", info->trigger);
750                 perf_bp_event(wp, regs);
751
752                 /*
753                  * If no overflow handler is present, insert a temporary
754                  * mismatch breakpoint so we can single-step over the
755                  * watchpoint trigger.
756                  */
757                 if (!wp->overflow_handler)
758                         enable_single_step(wp, instruction_pointer(regs));
759
760 unlock:
761                 rcu_read_unlock();
762         }
763 }
764
765 static void watchpoint_single_step_handler(unsigned long pc)
766 {
767         int i;
768         struct perf_event *wp, **slots;
769         struct arch_hw_breakpoint *info;
770
771         slots = (struct perf_event **)__get_cpu_var(wp_on_reg);
772
773         for (i = 0; i < core_num_wrps; ++i) {
774                 rcu_read_lock();
775
776                 wp = slots[i];
777
778                 if (wp == NULL)
779                         goto unlock;
780
781                 info = counter_arch_bp(wp);
782                 if (!info->step_ctrl.enabled)
783                         goto unlock;
784
785                 /*
786                  * Restore the original watchpoint if we've completed the
787                  * single-step.
788                  */
789                 if (info->trigger != pc)
790                         disable_single_step(wp);
791
792 unlock:
793                 rcu_read_unlock();
794         }
795 }
796
797 static void breakpoint_handler(unsigned long unknown, struct pt_regs *regs)
798 {
799         int i;
800         u32 ctrl_reg, val, addr;
801         struct perf_event *bp, **slots;
802         struct arch_hw_breakpoint *info;
803         struct arch_hw_breakpoint_ctrl ctrl;
804
805         slots = (struct perf_event **)__get_cpu_var(bp_on_reg);
806
807         /* The exception entry code places the amended lr in the PC. */
808         addr = regs->ARM_pc;
809
810         /* Check the currently installed breakpoints first. */
811         for (i = 0; i < core_num_brps; ++i) {
812                 rcu_read_lock();
813
814                 bp = slots[i];
815
816                 if (bp == NULL)
817                         goto unlock;
818
819                 info = counter_arch_bp(bp);
820
821                 /* Check if the breakpoint value matches. */
822                 val = read_wb_reg(ARM_BASE_BVR + i);
823                 if (val != (addr & ~0x3))
824                         goto mismatch;
825
826                 /* Possible match, check the byte address select to confirm. */
827                 ctrl_reg = read_wb_reg(ARM_BASE_BCR + i);
828                 decode_ctrl_reg(ctrl_reg, &ctrl);
829                 if ((1 << (addr & 0x3)) & ctrl.len) {
830                         info->trigger = addr;
831                         pr_debug("breakpoint fired: address = 0x%x\n", addr);
832                         perf_bp_event(bp, regs);
833                         if (!bp->overflow_handler)
834                                 enable_single_step(bp, addr);
835                         goto unlock;
836                 }
837
838 mismatch:
839                 /* If we're stepping a breakpoint, it can now be restored. */
840                 if (info->step_ctrl.enabled)
841                         disable_single_step(bp);
842 unlock:
843                 rcu_read_unlock();
844         }
845
846         /* Handle any pending watchpoint single-step breakpoints. */
847         watchpoint_single_step_handler(addr);
848 }
849
850 /*
851  * Called from either the Data Abort Handler [watchpoint] or the
852  * Prefetch Abort Handler [breakpoint] with interrupts disabled.
853  */
854 static int hw_breakpoint_pending(unsigned long addr, unsigned int fsr,
855                                  struct pt_regs *regs)
856 {
857         int ret = 0;
858         u32 dscr;
859
860         preempt_disable();
861
862         if (interrupts_enabled(regs))
863                 local_irq_enable();
864
865         /* We only handle watchpoints and hardware breakpoints. */
866         ARM_DBG_READ(c0, c1, 0, dscr);
867
868         /* Perform perf callbacks. */
869         switch (ARM_DSCR_MOE(dscr)) {
870         case ARM_ENTRY_BREAKPOINT:
871                 breakpoint_handler(addr, regs);
872                 break;
873         case ARM_ENTRY_ASYNC_WATCHPOINT:
874                 WARN(1, "Asynchronous watchpoint exception taken. Debugging results may be unreliable\n");
875         case ARM_ENTRY_SYNC_WATCHPOINT:
876                 watchpoint_handler(addr, fsr, regs);
877                 break;
878         default:
879                 ret = 1; /* Unhandled fault. */
880         }
881
882         preempt_enable();
883
884         return ret;
885 }
886
887 /*
888  * One-time initialisation.
889  */
890 static cpumask_t debug_err_mask;
891
892 static int debug_reg_trap(struct pt_regs *regs, unsigned int instr)
893 {
894         int cpu = smp_processor_id();
895
896         pr_warning("Debug register access (0x%x) caused undefined instruction on CPU %d\n",
897                    instr, cpu);
898
899         /* Set the error flag for this CPU and skip the faulting instruction. */
900         cpumask_set_cpu(cpu, &debug_err_mask);
901         instruction_pointer(regs) += 4;
902         return 0;
903 }
904
905 static struct undef_hook debug_reg_hook = {
906         .instr_mask     = 0x0fe80f10,
907         .instr_val      = 0x0e000e10,
908         .fn             = debug_reg_trap,
909 };
910
911 /* Does this core support OS Save and Restore? */
912 static bool core_has_os_save_restore(void)
913 {
914         u32 oslsr;
915
916         switch (get_debug_arch()) {
917         case ARM_DEBUG_ARCH_V7_1:
918                 return true;
919         case ARM_DEBUG_ARCH_V7_ECP14:
920                 ARM_DBG_READ(c1, c1, 4, oslsr);
921                 if (oslsr & ARM_OSLSR_OSLM0)
922                         return true;
923         default:
924                 return false;
925         }
926 }
927
928 static void reset_ctrl_regs(void *unused)
929 {
930         int i, raw_num_brps, err = 0, cpu = smp_processor_id();
931         u32 val;
932
933         /*
934          * v7 debug contains save and restore registers so that debug state
935          * can be maintained across low-power modes without leaving the debug
936          * logic powered up. It is IMPLEMENTATION DEFINED whether we can access
937          * the debug registers out of reset, so we must unlock the OS Lock
938          * Access Register to avoid taking undefined instruction exceptions
939          * later on.
940          */
941         switch (debug_arch) {
942         case ARM_DEBUG_ARCH_V6:
943         case ARM_DEBUG_ARCH_V6_1:
944                 /* ARMv6 cores clear the registers out of reset. */
945                 goto out_mdbgen;
946         case ARM_DEBUG_ARCH_V7_ECP14:
947                 /*
948                  * Ensure sticky power-down is clear (i.e. debug logic is
949                  * powered up).
950                  */
951                 ARM_DBG_READ(c1, c5, 4, val);
952                 if ((val & 0x1) == 0)
953                         err = -EPERM;
954
955                 if (!has_ossr)
956                         goto clear_vcr;
957                 break;
958         case ARM_DEBUG_ARCH_V7_1:
959                 /*
960                  * Ensure the OS double lock is clear.
961                  */
962                 ARM_DBG_READ(c1, c3, 4, val);
963                 if ((val & 0x1) == 1)
964                         err = -EPERM;
965                 break;
966         }
967
968         if (err) {
969                 pr_warn_once("CPU %d debug is powered down!\n", cpu);
970                 cpumask_or(&debug_err_mask, &debug_err_mask, cpumask_of(cpu));
971                 return;
972         }
973
974         /*
975          * Unconditionally clear the OS lock by writing a value
976          * other than CS_LAR_KEY to the access register.
977          */
978         ARM_DBG_WRITE(c1, c0, 4, ~CS_LAR_KEY);
979         isb();
980
981         /*
982          * Clear any configured vector-catch events before
983          * enabling monitor mode.
984          */
985 clear_vcr:
986         ARM_DBG_WRITE(c0, c7, 0, 0);
987         isb();
988
989         if (cpumask_intersects(&debug_err_mask, cpumask_of(cpu))) {
990                 pr_warn_once("CPU %d failed to disable vector catch\n", cpu);
991                 return;
992         }
993
994         /*
995          * The control/value register pairs are UNKNOWN out of reset so
996          * clear them to avoid spurious debug events.
997          */
998         raw_num_brps = get_num_brp_resources();
999         for (i = 0; i < raw_num_brps; ++i) {
1000                 write_wb_reg(ARM_BASE_BCR + i, 0UL);
1001                 write_wb_reg(ARM_BASE_BVR + i, 0UL);
1002         }
1003
1004         for (i = 0; i < core_num_wrps; ++i) {
1005                 write_wb_reg(ARM_BASE_WCR + i, 0UL);
1006                 write_wb_reg(ARM_BASE_WVR + i, 0UL);
1007         }
1008
1009         if (cpumask_intersects(&debug_err_mask, cpumask_of(cpu))) {
1010                 pr_warn_once("CPU %d failed to clear debug register pairs\n", cpu);
1011                 return;
1012         }
1013
1014         /*
1015          * Have a crack at enabling monitor mode. We don't actually need
1016          * it yet, but reporting an error early is useful if it fails.
1017          */
1018 out_mdbgen:
1019         if (enable_monitor_mode())
1020                 cpumask_or(&debug_err_mask, &debug_err_mask, cpumask_of(cpu));
1021 }
1022
1023 static int __cpuinit dbg_reset_notify(struct notifier_block *self,
1024                                       unsigned long action, void *cpu)
1025 {
1026         if ((action & ~CPU_TASKS_FROZEN) == CPU_ONLINE)
1027                 smp_call_function_single((int)cpu, reset_ctrl_regs, NULL, 1);
1028
1029         return NOTIFY_OK;
1030 }
1031
1032 static struct notifier_block __cpuinitdata dbg_reset_nb = {
1033         .notifier_call = dbg_reset_notify,
1034 };
1035
1036 #ifdef CONFIG_CPU_PM
1037 static int dbg_cpu_pm_notify(struct notifier_block *self, unsigned long action,
1038                              void *v)
1039 {
1040         if (action == CPU_PM_EXIT)
1041                 reset_ctrl_regs(NULL);
1042
1043         return NOTIFY_OK;
1044 }
1045
1046 static struct notifier_block dbg_cpu_pm_nb = {
1047         .notifier_call = dbg_cpu_pm_notify,
1048 };
1049
1050 static void __init pm_init(void)
1051 {
1052         cpu_pm_register_notifier(&dbg_cpu_pm_nb);
1053 }
1054 #else
1055 static inline void pm_init(void)
1056 {
1057 }
1058 #endif
1059
1060 static int __init arch_hw_breakpoint_init(void)
1061 {
1062         debug_arch = get_debug_arch();
1063
1064         if (!debug_arch_supported()) {
1065                 pr_info("debug architecture 0x%x unsupported.\n", debug_arch);
1066                 return 0;
1067         }
1068
1069         has_ossr = core_has_os_save_restore();
1070
1071         /* Determine how many BRPs/WRPs are available. */
1072         core_num_brps = get_num_brps();
1073         core_num_wrps = get_num_wrps();
1074
1075         /*
1076          * We need to tread carefully here because DBGSWENABLE may be
1077          * driven low on this core and there isn't an architected way to
1078          * determine that.
1079          */
1080         register_undef_hook(&debug_reg_hook);
1081
1082         /*
1083          * Reset the breakpoint resources. We assume that a halting
1084          * debugger will leave the world in a nice state for us.
1085          */
1086         on_each_cpu(reset_ctrl_regs, NULL, 1);
1087         unregister_undef_hook(&debug_reg_hook);
1088         if (!cpumask_empty(&debug_err_mask)) {
1089                 core_num_brps = 0;
1090                 core_num_wrps = 0;
1091                 return 0;
1092         }
1093
1094         pr_info("found %d " "%s" "breakpoint and %d watchpoint registers.\n",
1095                 core_num_brps, core_has_mismatch_brps() ? "(+1 reserved) " :
1096                 "", core_num_wrps);
1097
1098         /* Work out the maximum supported watchpoint length. */
1099         max_watchpoint_len = get_max_wp_len();
1100         pr_info("maximum watchpoint size is %u bytes.\n",
1101                         max_watchpoint_len);
1102
1103         /* Register debug fault handler. */
1104         hook_fault_code(FAULT_CODE_DEBUG, hw_breakpoint_pending, SIGTRAP,
1105                         TRAP_HWBKPT, "watchpoint debug exception");
1106         hook_ifault_code(FAULT_CODE_DEBUG, hw_breakpoint_pending, SIGTRAP,
1107                         TRAP_HWBKPT, "breakpoint debug exception");
1108
1109         /* Register hotplug and PM notifiers. */
1110         register_cpu_notifier(&dbg_reset_nb);
1111         pm_init();
1112         return 0;
1113 }
1114 arch_initcall(arch_hw_breakpoint_init);
1115
1116 void hw_breakpoint_pmu_read(struct perf_event *bp)
1117 {
1118 }
1119
1120 /*
1121  * Dummy function to register with die_notifier.
1122  */
1123 int hw_breakpoint_exceptions_notify(struct notifier_block *unused,
1124                                         unsigned long val, void *data)
1125 {
1126         return NOTIFY_DONE;
1127 }