arch/arm/kernel/perf_event.c

   1 #undef DEBUG
   2
   3 /*
   4  * ARM performance counter support.
   5  *
   6  * Copyright (C) 2009 picoChip Designs, Ltd., Jamie Iles
   7  * Copyright (C) 2010 ARM Ltd., Will Deacon <will.deacon@arm.com>
   8  *
   9  * This code is based on the sparc64 perf event code, which is in turn based
  10  * on the x86 code. Callchain code is based on the ARM OProfile backtrace
  11  * code.
  12  */
  13 #define pr_fmt(fmt) "hw perfevents: " fmt
  14
  15 #include <linux/interrupt.h>
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/perf_event.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/spinlock.h>
  21 #include <linux/uaccess.h>
  22
  23 #include <asm/cputype.h>
  24 #include <asm/irq.h>
  25 #include <asm/irq_regs.h>
  26 #include <asm/pmu.h>
  27 #include <asm/stacktrace.h>
  28
  29 static struct platform_device *pmu_device;
  30
  31 /*
  32  * Hardware lock to serialize accesses to PMU registers. Needed for the
  33  * read/modify/write sequences.
  34  */
  35 static DEFINE_RAW_SPINLOCK(pmu_lock);
  36
  37 /*
  38  * ARMv6 supports a maximum of 3 events, starting from index 0. If we add
  39  * another platform that supports more, we need to increase this to be the
  40  * largest of all platforms.
  41  *
  42  * ARMv7 supports up to 32 events:
  43  *  cycle counter CCNT + 31 events counters CNT0..30.
  44  *  Cortex-A8 has 1+4 counters, Cortex-A9 has 1+6 counters.
  45  */
  46 #define ARMPMU_MAX_HWEVENTS             32
  47
  48 /* The events for a given CPU. */
  49 struct cpu_hw_events {
  50         /*
  51          * The events that are active on the CPU for the given index.
  52          */
  53         struct perf_event       *events[ARMPMU_MAX_HWEVENTS];
  54
  55         /*
  56          * A 1 bit for an index indicates that the counter is being used for
  57          * an event. A 0 means that the counter can be used.
  58          */
  59         unsigned long           used_mask[BITS_TO_LONGS(ARMPMU_MAX_HWEVENTS)];
  60
  61         /*
  62          * A 1 bit for an index indicates that the counter is actively being
  63          * used.
  64          */
  65         unsigned long           active_mask[BITS_TO_LONGS(ARMPMU_MAX_HWEVENTS)];
  66 };
  67 static DEFINE_PER_CPU(struct cpu_hw_events, cpu_hw_events);
  68
  69 struct arm_pmu {
  70         enum arm_perf_pmu_ids id;
  71         cpumask_t       active_irqs;
  72         const char      *name;
  73         irqreturn_t     (*handle_irq)(int irq_num, void *dev);
  74         void            (*enable)(struct hw_perf_event *evt, int idx);
  75         void            (*disable)(struct hw_perf_event *evt, int idx);
  76         int             (*get_event_idx)(struct cpu_hw_events *cpuc,
  77                                          struct hw_perf_event *hwc);
  78         int             (*set_event_filter)(struct hw_perf_event *evt,
  79                                             struct perf_event_attr *attr);
  80         u32             (*read_counter)(int idx);
  81         void            (*write_counter)(int idx, u32 val);
  82         void            (*start)(void);
  83         void            (*stop)(void);
  84         void            (*reset)(void *);
  85         const unsigned  (*cache_map)[PERF_COUNT_HW_CACHE_MAX]
  86                                     [PERF_COUNT_HW_CACHE_OP_MAX]
  87                                     [PERF_COUNT_HW_CACHE_RESULT_MAX];
  88         const unsigned  (*event_map)[PERF_COUNT_HW_MAX];
  89         u32             raw_event_mask;
  90         int             num_events;
  91         u64             max_period;
  92 };
  93
  94 /* Set at runtime when we know what CPU type we are. */
  95 static struct arm_pmu *armpmu;
  96
  97 enum arm_perf_pmu_ids
  98 armpmu_get_pmu_id(void)
  99 {
 100         int id = -ENODEV;
 101
 102         if (armpmu != NULL)
 103                 id = armpmu->id;
 104
 105         return id;
 106 }
 107 EXPORT_SYMBOL_GPL(armpmu_get_pmu_id);
 108
 109 int
 110 armpmu_get_max_events(void)
 111 {
 112         int max_events = 0;
 113
 114         if (armpmu != NULL)
 115                 max_events = armpmu->num_events;
 116
 117         return max_events;
 118 }
 119 EXPORT_SYMBOL_GPL(armpmu_get_max_events);
 120
 121 int perf_num_counters(void)
 122 {
 123         return armpmu_get_max_events();
 124 }
 125 EXPORT_SYMBOL_GPL(perf_num_counters);
 126
 127 #define HW_OP_UNSUPPORTED               0xFFFF
 128
 129 #define C(_x) \
 130         PERF_COUNT_HW_CACHE_##_x
 131
 132 #define CACHE_OP_UNSUPPORTED            0xFFFF
 133
 134 static int
 135 armpmu_map_cache_event(u64 config)
 136 {
 137         unsigned int cache_type, cache_op, cache_result, ret;
 138
 139         cache_type = (config >>  0) & 0xff;
 140         if (cache_type >= PERF_COUNT_HW_CACHE_MAX)
 141                 return -EINVAL;
 142
 143         cache_op = (config >>  8) & 0xff;
 144         if (cache_op >= PERF_COUNT_HW_CACHE_OP_MAX)
 145                 return -EINVAL;
 146
 147         cache_result = (config >> 16) & 0xff;
 148         if (cache_result >= PERF_COUNT_HW_CACHE_RESULT_MAX)
 149                 return -EINVAL;
 150
 151         ret = (int)(*armpmu->cache_map)[cache_type][cache_op][cache_result];
 152
 153         if (ret == CACHE_OP_UNSUPPORTED)
 154                 return -ENOENT;
 155
 156         return ret;
 157 }
 158
 159 static int
 160 armpmu_map_event(u64 config)
 161 {
 162         int mapping = (*armpmu->event_map)[config];
 163         return mapping == HW_OP_UNSUPPORTED ? -EOPNOTSUPP : mapping;
 164 }
 165
 166 static int
 167 armpmu_map_raw_event(u64 config)
 168 {
 169         return (int)(config & armpmu->raw_event_mask);
 170 }
 171
 172 static int
 173 armpmu_event_set_period(struct perf_event *event,
 174                         struct hw_perf_event *hwc,
 175                         int idx)
 176 {
 177         s64 left = local64_read(&hwc->period_left);
 178         s64 period = hwc->sample_period;
 179         int ret = 0;
 180
 181         if (unlikely(left <= -period)) {
 182                 left = period;
 183                 local64_set(&hwc->period_left, left);
 184                 hwc->last_period = period;
 185                 ret = 1;
 186         }
 187
 188         if (unlikely(left <= 0)) {
 189                 left += period;
 190                 local64_set(&hwc->period_left, left);
 191                 hwc->last_period = period;
 192                 ret = 1;
 193         }
 194
 195         if (left > (s64)armpmu->max_period)
 196                 left = armpmu->max_period;
 197
 198         local64_set(&hwc->prev_count, (u64)-left);
 199
 200         armpmu->write_counter(idx, (u64)(-left) & 0xffffffff);
 201
 202         perf_event_update_userpage(event);
 203
 204         return ret;
 205 }
 206
 207 static u64
 208 armpmu_event_update(struct perf_event *event,
 209                     struct hw_perf_event *hwc,
 210                     int idx, int overflow)
 211 {
 212         u64 delta, prev_raw_count, new_raw_count;
 213
 214 again:
 215         prev_raw_count = local64_read(&hwc->prev_count);
 216         new_raw_count = armpmu->read_counter(idx);
 217
 218         if (local64_cmpxchg(&hwc->prev_count, prev_raw_count,
 219                              new_raw_count) != prev_raw_count)
 220                 goto again;
 221
 222         new_raw_count &= armpmu->max_period;
 223         prev_raw_count &= armpmu->max_period;
 224
 225         if (overflow)
 226                 delta = armpmu->max_period - prev_raw_count + new_raw_count + 1;
 227         else
 228                 delta = new_raw_count - prev_raw_count;
 229
 230         local64_add(delta, &event->count);
 231         local64_sub(delta, &hwc->period_left);
 232
 233         return new_raw_count;
 234 }
 235
 236 static void
 237 armpmu_read(struct perf_event *event)
 238 {
 239         struct hw_perf_event *hwc = &event->hw;
 240
 241         /* Don't read disabled counters! */
 242         if (hwc->idx < 0)
 243                 return;
 244
 245         armpmu_event_update(event, hwc, hwc->idx, 0);
 246 }
 247
 248 static void
 249 armpmu_stop(struct perf_event *event, int flags)
 250 {
 251         struct hw_perf_event *hwc = &event->hw;
 252
 253         /*
 254          * ARM pmu always has to update the counter, so ignore
 255          * PERF_EF_UPDATE, see comments in armpmu_start().
 256          */
 257         if (!(hwc->state & PERF_HES_STOPPED)) {
 258                 armpmu->disable(hwc, hwc->idx);
 259                 barrier(); /* why? */
 260                 armpmu_event_update(event, hwc, hwc->idx, 0);
 261                 hwc->state |= PERF_HES_STOPPED | PERF_HES_UPTODATE;
 262         }
 263 }
 264
 265 static void
 266 armpmu_start(struct perf_event *event, int flags)
 267 {
 268         struct hw_perf_event *hwc = &event->hw;
 269
 270         /*
 271          * ARM pmu always has to reprogram the period, so ignore
 272          * PERF_EF_RELOAD, see the comment below.
 273          */
 274         if (flags & PERF_EF_RELOAD)
 275                 WARN_ON_ONCE(!(hwc->state & PERF_HES_UPTODATE));
 276
 277         hwc->state = 0;
 278         /*
 279          * Set the period again. Some counters can't be stopped, so when we
 280          * were stopped we simply disabled the IRQ source and the counter
 281          * may have been left counting. If we don't do this step then we may
 282          * get an interrupt too soon or *way* too late if the overflow has
 283          * happened since disabling.
 284          */
 285         armpmu_event_set_period(event, hwc, hwc->idx);
 286         armpmu->enable(hwc, hwc->idx);
 287 }
 288
 289 static void
 290 armpmu_del(struct perf_event *event, int flags)
 291 {
 292         struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
 293         struct hw_perf_event *hwc = &event->hw;
 294         int idx = hwc->idx;
 295
 296         WARN_ON(idx < 0);
 297
 298         clear_bit(idx, cpuc->active_mask);
 299         armpmu_stop(event, PERF_EF_UPDATE);
 300         cpuc->events[idx] = NULL;
 301         clear_bit(idx, cpuc->used_mask);
 302
 303         perf_event_update_userpage(event);
 304 }
 305
 306 static int
 307 armpmu_add(struct perf_event *event, int flags)
 308 {
 309         struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
 310         struct hw_perf_event *hwc = &event->hw;
 311         int idx;
 312         int err = 0;
 313
 314         perf_pmu_disable(event->pmu);
 315
 316         /* If we don't have a space for the counter then finish early. */
 317         idx = armpmu->get_event_idx(cpuc, hwc);
 318         if (idx < 0) {
 319                 err = idx;
 320                 goto out;
 321         }
 322
 323         /*
 324          * If there is an event in the counter we are going to use then make
 325          * sure it is disabled.
 326          */
 327         event->hw.idx = idx;
 328         armpmu->disable(hwc, idx);
 329         cpuc->events[idx] = event;
 330         set_bit(idx, cpuc->active_mask);
 331
 332         hwc->state = PERF_HES_STOPPED | PERF_HES_UPTODATE;
 333         if (flags & PERF_EF_START)
 334                 armpmu_start(event, PERF_EF_RELOAD);
 335
 336         /* Propagate our changes to the userspace mapping. */
 337         perf_event_update_userpage(event);
 338
 339 out:
 340         perf_pmu_enable(event->pmu);
 341         return err;
 342 }
 343
 344 static struct pmu pmu;
 345
 346 static int
 347 validate_event(struct cpu_hw_events *cpuc,
 348                struct perf_event *event)
 349 {
 350         struct hw_perf_event fake_event = event->hw;
 351         struct pmu *leader_pmu = event->group_leader->pmu;
 352
 353         if (event->pmu != leader_pmu || event->state <= PERF_EVENT_STATE_OFF)
 354                 return 1;
 355
 356         return armpmu->get_event_idx(cpuc, &fake_event) >= 0;
 357 }
 358
 359 static int
 360 validate_group(struct perf_event *event)
 361 {
 362         struct perf_event *sibling, *leader = event->group_leader;
 363         struct cpu_hw_events fake_pmu;
 364
 365         memset(&fake_pmu, 0, sizeof(fake_pmu));
 366
 367         if (!validate_event(&fake_pmu, leader))
 368                 return -ENOSPC;
 369
 370         list_for_each_entry(sibling, &leader->sibling_list, group_entry) {
 371                 if (!validate_event(&fake_pmu, sibling))
 372                         return -ENOSPC;
 373         }
 374
 375         if (!validate_event(&fake_pmu, event))
 376                 return -ENOSPC;
 377
 378         return 0;
 379 }
 380
 381 static irqreturn_t armpmu_platform_irq(int irq, void *dev)
 382 {
 383         struct arm_pmu_platdata *plat = dev_get_platdata(&pmu_device->dev);
 384
 385         return plat->handle_irq(irq, dev, armpmu->handle_irq);
 386 }
 387
 388 static void
 389 armpmu_release_hardware(void)
 390 {
 391         int i, irq, irqs;
 392
 393         irqs = min(pmu_device->num_resources, num_possible_cpus());
 394
 395         for (i = 0; i < irqs; ++i) {
 396                 if (!cpumask_test_and_clear_cpu(i, &armpmu->active_irqs))
 397                         continue;
 398                 irq = platform_get_irq(pmu_device, i);
 399                 if (irq >= 0)
 400                         free_irq(irq, NULL);
 401         }
 402
 403         armpmu->stop();
 404         release_pmu(ARM_PMU_DEVICE_CPU);
 405 }
 406
 407 static int
 408 armpmu_reserve_hardware(void)
 409 {
 410         struct arm_pmu_platdata *plat;
 411         irq_handler_t handle_irq;
 412         int i, err, irq, irqs;
 413
 414         err = reserve_pmu(ARM_PMU_DEVICE_CPU);
 415         if (err) {
 416                 pr_warning("unable to reserve pmu\n");
 417                 return err;
 418         }
 419
 420         plat = dev_get_platdata(&pmu_device->dev);
 421         if (plat && plat->handle_irq)
 422                 handle_irq = armpmu_platform_irq;
 423         else
 424                 handle_irq = armpmu->handle_irq;
 425
 426         irqs = min(pmu_device->num_resources, num_possible_cpus());
 427         if (irqs < 1) {
 428                 pr_err("no irqs for PMUs defined\n");
 429                 return -ENODEV;
 430         }
 431
 432         for (i = 0; i < irqs; ++i) {
 433                 err = 0;
 434                 irq = platform_get_irq(pmu_device, i);
 435                 if (irq < 0)
 436                         continue;
 437
 438                 /*
 439                  * If we have a single PMU interrupt that we can't shift,
 440                  * assume that we're running on a uniprocessor machine and
 441                  * continue. Otherwise, continue without this interrupt.
 442                  */
 443                 if (irq_set_affinity(irq, cpumask_of(i)) && irqs > 1) {
 444                         pr_warning("unable to set irq affinity (irq=%d, cpu=%u)\n",
 445                                     irq, i);
 446                         continue;
 447                 }
 448
 449                 err = request_irq(irq, handle_irq,
 450                                   IRQF_DISABLED | IRQF_NOBALANCING,
 451                                   "arm-pmu", NULL);
 452                 if (err) {
 453                         pr_err("unable to request IRQ%d for ARM PMU counters\n",
 454                                 irq);
 455                         armpmu_release_hardware();
 456                         return err;
 457                 }
 458
 459                 cpumask_set_cpu(i, &armpmu->active_irqs);
 460         }
 461
 462         return 0;
 463 }
 464
 465 static atomic_t active_events = ATOMIC_INIT(0);
 466 static DEFINE_MUTEX(pmu_reserve_mutex);
 467
 468 static void
 469 hw_perf_event_destroy(struct perf_event *event)
 470 {
 471         if (atomic_dec_and_mutex_lock(&active_events, &pmu_reserve_mutex)) {
 472                 armpmu_release_hardware();
 473                 mutex_unlock(&pmu_reserve_mutex);
 474         }
 475 }
 476
 477 static int
 478 event_requires_mode_exclusion(struct perf_event_attr *attr)
 479 {
 480         return attr->exclude_idle || attr->exclude_user ||
 481                attr->exclude_kernel || attr->exclude_hv;
 482 }
 483
 484 static int
 485 __hw_perf_event_init(struct perf_event *event)
 486 {
 487         struct hw_perf_event *hwc = &event->hw;
 488         int mapping, err;
 489
 490         /* Decode the generic type into an ARM event identifier. */
 491         if (PERF_TYPE_HARDWARE == event->attr.type) {
 492                 mapping = armpmu_map_event(event->attr.config);
 493         } else if (PERF_TYPE_HW_CACHE == event->attr.type) {
 494                 mapping = armpmu_map_cache_event(event->attr.config);
 495         } else if (PERF_TYPE_RAW == event->attr.type) {
 496                 mapping = armpmu_map_raw_event(event->attr.config);
 497         } else {
 498                 pr_debug("event type %x not supported\n", event->attr.type);
 499                 return -EOPNOTSUPP;
 500         }
 501
 502         if (mapping < 0) {
 503                 pr_debug("event %x:%llx not supported\n", event->attr.type,
 504                          event->attr.config);
 505                 return mapping;
 506         }
 507
 508         /*
 509          * We don't assign an index until we actually place the event onto
 510          * hardware. Use -1 to signify that we haven't decided where to put it
 511          * yet. For SMP systems, each core has it's own PMU so we can't do any
 512          * clever allocation or constraints checking at this point.
 513          */
 514         hwc->idx                = -1;
 515         hwc->config_base        = 0;
 516         hwc->config             = 0;
 517         hwc->event_base         = 0;
 518
 519         /*
 520          * Check whether we need to exclude the counter from certain modes.
 521          */
 522         if ((!armpmu->set_event_filter ||
 523              armpmu->set_event_filter(hwc, &event->attr)) &&
 524              event_requires_mode_exclusion(&event->attr)) {
 525                 pr_debug("ARM performance counters do not support "
 526                          "mode exclusion\n");
 527                 return -EPERM;
 528         }
 529
 530         /*
 531          * Store the event encoding into the config_base field.
 532          */
 533         hwc->config_base            |= (unsigned long)mapping;
 534
 535         if (!hwc->sample_period) {
 536                 hwc->sample_period  = armpmu->max_period;
 537                 hwc->last_period    = hwc->sample_period;
 538                 local64_set(&hwc->period_left, hwc->sample_period);
 539         }
 540
 541         err = 0;
 542         if (event->group_leader != event) {
 543                 err = validate_group(event);
 544                 if (err)
 545                         return -EINVAL;
 546         }
 547
 548         return err;
 549 }
 550
 551 static int armpmu_event_init(struct perf_event *event)
 552 {
 553         int err = 0;
 554
 555         switch (event->attr.type) {
 556         case PERF_TYPE_RAW:
 557         case PERF_TYPE_HARDWARE:
 558         case PERF_TYPE_HW_CACHE:
 559                 break;
 560
 561         default:
 562                 return -ENOENT;
 563         }
 564
 565         event->destroy = hw_perf_event_destroy;
 566
 567         if (!atomic_inc_not_zero(&active_events)) {
 568                 mutex_lock(&pmu_reserve_mutex);
 569                 if (atomic_read(&active_events) == 0) {
 570                         err = armpmu_reserve_hardware();
 571                 }
 572
 573                 if (!err)
 574                         atomic_inc(&active_events);
 575                 mutex_unlock(&pmu_reserve_mutex);
 576         }
 577
 578         if (err)
 579                 return err;
 580
 581         err = __hw_perf_event_init(event);
 582         if (err)
 583                 hw_perf_event_destroy(event);
 584
 585         return err;
 586 }
 587
 588 static void armpmu_enable(struct pmu *pmu)
 589 {
 590         /* Enable all of the perf events on hardware. */
 591         int idx, enabled = 0;
 592         struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
 593
 594         for (idx = 0; idx < armpmu->num_events; ++idx) {
 595                 struct perf_event *event = cpuc->events[idx];
 596
 597                 if (!event)
 598                         continue;
 599
 600                 armpmu->enable(&event->hw, idx);
 601                 enabled = 1;
 602         }
 603
 604         if (enabled)
 605                 armpmu->start();
 606 }
 607
 608 static void armpmu_disable(struct pmu *pmu)
 609 {
 610         armpmu->stop();
 611 }
 612
 613 static struct pmu pmu = {
 614         .pmu_enable     = armpmu_enable,
 615         .pmu_disable    = armpmu_disable,
 616         .event_init     = armpmu_event_init,
 617         .add            = armpmu_add,
 618         .del            = armpmu_del,
 619         .start          = armpmu_start,
 620         .stop           = armpmu_stop,
 621         .read           = armpmu_read,
 622 };
 623
 624 /* Include the PMU-specific implementations. */
 625 #include "perf_event_xscale.c"
 626 #include "perf_event_v6.c"
 627 #include "perf_event_v7.c"
 628
 629 /*
 630  * Ensure the PMU has sane values out of reset.
 631  * This requires SMP to be available, so exists as a separate initcall.
 632  */
 633 static int __init
 634 armpmu_reset(void)
 635 {
 636         if (armpmu && armpmu->reset)
 637                 return on_each_cpu(armpmu->reset, NULL, 1);
 638         return 0;
 639 }
 640 arch_initcall(armpmu_reset);
 641
 642 /*
 643  * PMU platform driver and devicetree bindings.
 644  */
 645 static struct of_device_id armpmu_of_device_ids[] = {
 646         {.compatible = "arm,cortex-a9-pmu"},
 647         {.compatible = "arm,cortex-a8-pmu"},
 648         {.compatible = "arm,arm1136-pmu"},
 649         {.compatible = "arm,arm1176-pmu"},
 650         {},
 651 };
 652
 653 static struct platform_device_id armpmu_plat_device_ids[] = {
 654         {.name = "arm-pmu"},
 655         {},
 656 };
 657
 658 static int __devinit armpmu_device_probe(struct platform_device *pdev)
 659 {
 660         pmu_device = pdev;
 661         return 0;
 662 }
 663
 664 static struct platform_driver armpmu_driver = {
 665         .driver         = {
 666                 .name   = "arm-pmu",
 667                 .of_match_table = armpmu_of_device_ids,
 668         },
 669         .probe          = armpmu_device_probe,
 670         .id_table       = armpmu_plat_device_ids,
 671 };
 672
 673 static int __init register_pmu_driver(void)
 674 {
 675         return platform_driver_register(&armpmu_driver);
 676 }
 677 device_initcall(register_pmu_driver);
 678
 679 /*
 680  * CPU PMU identification and registration.
 681  */
 682 static int __init
 683 init_hw_perf_events(void)
 684 {
 685         unsigned long cpuid = read_cpuid_id();
 686         unsigned long implementor = (cpuid & 0xFF000000) >> 24;
 687         unsigned long part_number = (cpuid & 0xFFF0);
 688
 689         /* ARM Ltd CPUs. */
 690         if (0x41 == implementor) {
 691                 switch (part_number) {
 692                 case 0xB360:    /* ARM1136 */
 693                 case 0xB560:    /* ARM1156 */
 694                 case 0xB760:    /* ARM1176 */
 695                         armpmu = armv6pmu_init();
 696                         break;
 697                 case 0xB020:    /* ARM11mpcore */
 698                         armpmu = armv6mpcore_pmu_init();
 699                         break;
 700                 case 0xC080:    /* Cortex-A8 */
 701                         armpmu = armv7_a8_pmu_init();
 702                         break;
 703                 case 0xC090:    /* Cortex-A9 */
 704                         armpmu = armv7_a9_pmu_init();
 705                         break;
 706                 case 0xC050:    /* Cortex-A5 */
 707                         armpmu = armv7_a5_pmu_init();
 708                         break;
 709                 case 0xC0F0:    /* Cortex-A15 */
 710                         armpmu = armv7_a15_pmu_init();
 711                         break;
 712                 }
 713         /* Intel CPUs [xscale]. */
 714         } else if (0x69 == implementor) {
 715                 part_number = (cpuid >> 13) & 0x7;
 716                 switch (part_number) {
 717                 case 1:
 718                         armpmu = xscale1pmu_init();
 719                         break;
 720                 case 2:
 721                         armpmu = xscale2pmu_init();
 722                         break;
 723                 }
 724         }
 725
 726         if (armpmu) {
 727                 pr_info("enabled with %s PMU driver, %d counters available\n",
 728                         armpmu->name, armpmu->num_events);
 729                 perf_pmu_register(&pmu, "cpu", PERF_TYPE_RAW);
 730         } else {
 731                 pr_info("no hardware support available\n");
 732         }
 733
 734         return 0;
 735 }
 736 early_initcall(init_hw_perf_events);
 737
 738 /*
 739  * Callchain handling code.
 740  */
 741
 742 /*
 743  * The registers we're interested in are at the end of the variable
 744  * length saved register structure. The fp points at the end of this
 745  * structure so the address of this struct is:
 746  * (struct frame_tail *)(xxx->fp)-1
 747  *
 748  * This code has been adapted from the ARM OProfile support.
 749  */
 750 struct frame_tail {
 751         struct frame_tail __user *fp;
 752         unsigned long sp;
 753         unsigned long lr;
 754 } __attribute__((packed));
 755
 756 /*
 757  * Get the return address for a single stackframe and return a pointer to the
 758  * next frame tail.
 759  */
 760 static struct frame_tail __user *
 761 user_backtrace(struct frame_tail __user *tail,
 762                struct perf_callchain_entry *entry)
 763 {
 764         struct frame_tail buftail;
 765
 766         /* Also check accessibility of one struct frame_tail beyond */
 767         if (!access_ok(VERIFY_READ, tail, sizeof(buftail)))
 768                 return NULL;
 769         if (__copy_from_user_inatomic(&buftail, tail, sizeof(buftail)))
 770                 return NULL;
 771
 772         perf_callchain_store(entry, buftail.lr);
 773
 774         /*
 775          * Frame pointers should strictly progress back up the stack
 776          * (towards higher addresses).
 777          */
 778         if (tail + 1 >= buftail.fp)
 779                 return NULL;
 780
 781         return buftail.fp - 1;
 782 }
 783
 784 void
 785 perf_callchain_user(struct perf_callchain_entry *entry, struct pt_regs *regs)
 786 {
 787         struct frame_tail __user *tail;
 788
 789
 790         tail = (struct frame_tail __user *)regs->ARM_fp - 1;
 791
 792         while ((entry->nr < PERF_MAX_STACK_DEPTH) &&
 793                tail && !((unsigned long)tail & 0x3))
 794                 tail = user_backtrace(tail, entry);
 795 }
 796
 797 /*
 798  * Gets called by walk_stackframe() for every stackframe. This will be called
 799  * whist unwinding the stackframe and is like a subroutine return so we use
 800  * the PC.
 801  */
 802 static int
 803 callchain_trace(struct stackframe *fr,
 804                 void *data)
 805 {
 806         struct perf_callchain_entry *entry = data;
 807         perf_callchain_store(entry, fr->pc);
 808         return 0;
 809 }
 810
 811 void
 812 perf_callchain_kernel(struct perf_callchain_entry *entry, struct pt_regs *regs)
 813 {
 814         struct stackframe fr;
 815
 816         fr.fp = regs->ARM_fp;
 817         fr.sp = regs->ARM_sp;
 818         fr.lr = regs->ARM_lr;
 819         fr.pc = regs->ARM_pc;
 820         walk_stackframe(&fr, callchain_trace, entry);
 821 }