root/arch/parisc/kernel/perf.c

DEFINITIONS

1. perf_config
2. perf_open
3. perf_release
4. perf_read
5. perf_write
6. perf_patch_images
7. perf_ioctl
8. perf_init
9. perf_start_counters
10. perf_stop_counters
11. perf_rdr_get_entry
12. perf_rdr_read_ubuf
13. perf_rdr_clear
14. perf_write_image
15. perf_rdr_write

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  Parisc performance counters
   4  *  Copyright (C) 2001 Randolph Chung <tausq@debian.org>
   5  *
   6  *  This code is derived, with permission, from HP/UX sources.
   7  */
   8 
   9 /*
  10  *  Edited comment from original sources:
  11  *
  12  *  This driver programs the PCX-U/PCX-W performance counters
  13  *  on the PA-RISC 2.0 chips.  The driver keeps all images now
  14  *  internally to the kernel to hopefully eliminate the possibility
  15  *  of a bad image halting the CPU.  Also, there are different
  16  *  images for the PCX-W and later chips vs the PCX-U chips.
  17  *
  18  *  Only 1 process is allowed to access the driver at any time,
  19  *  so the only protection that is needed is at open and close.
  20  *  A variable "perf_enabled" is used to hold the state of the
  21  *  driver.  The spinlock "perf_lock" is used to protect the
  22  *  modification of the state during open/close operations so
  23  *  multiple processes don't get into the driver simultaneously.
  24  *
  25  *  This driver accesses the processor directly vs going through
  26  *  the PDC INTRIGUE calls.  This is done to eliminate bugs introduced
  27  *  in various PDC revisions.  The code is much more maintainable
  28  *  and reliable this way vs having to debug on every version of PDC
  29  *  on every box.
  30  */
  31 
  32 #include <linux/capability.h>
  33 #include <linux/init.h>
  34 #include <linux/proc_fs.h>
  35 #include <linux/miscdevice.h>
  36 #include <linux/spinlock.h>
  37 
  38 #include <linux/uaccess.h>
  39 #include <asm/perf.h>
  40 #include <asm/parisc-device.h>
  41 #include <asm/processor.h>
  42 #include <asm/runway.h>
  43 #include <asm/io.h>             /* for __raw_read() */
  44 
  45 #include "perf_images.h"
  46 
  47 #define MAX_RDR_WORDS   24
  48 #define PERF_VERSION    2       /* derived from hpux's PI v2 interface */
  49 
  50 /* definition of RDR regs */
  51 struct rdr_tbl_ent {
  52         uint16_t        width;
  53         uint8_t         num_words;
  54         uint8_t         write_control;
  55 };
  56 
  57 static int perf_processor_interface __read_mostly = UNKNOWN_INTF;
  58 static int perf_enabled __read_mostly;
  59 static DEFINE_SPINLOCK(perf_lock);
  60 struct parisc_device *cpu_device __read_mostly;
  61 
  62 /* RDRs to write for PCX-W */
  63 static const int perf_rdrs_W[] =
  64         { 0, 1, 4, 5, 6, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, -1 };
  65 
  66 /* RDRs to write for PCX-U */
  67 static const int perf_rdrs_U[] =
  68         { 0, 1, 4, 5, 6, 7, 16, 17, 18, 20, 21, 22, 23, 24, 25, -1 };
  69 
  70 /* RDR register descriptions for PCX-W */
  71 static const struct rdr_tbl_ent perf_rdr_tbl_W[] = {
  72         { 19,   1,      8 },   /* RDR 0 */
  73         { 16,   1,      16 },  /* RDR 1 */
  74         { 72,   2,      0 },   /* RDR 2 */
  75         { 81,   2,      0 },   /* RDR 3 */
  76         { 328,  6,      0 },   /* RDR 4 */
  77         { 160,  3,      0 },   /* RDR 5 */
  78         { 336,  6,      0 },   /* RDR 6 */
  79         { 164,  3,      0 },   /* RDR 7 */
  80         { 0,    0,      0 },   /* RDR 8 */
  81         { 35,   1,      0 },   /* RDR 9 */
  82         { 6,    1,      0 },   /* RDR 10 */
  83         { 18,   1,      0 },   /* RDR 11 */
  84         { 13,   1,      0 },   /* RDR 12 */
  85         { 8,    1,      0 },   /* RDR 13 */
  86         { 8,    1,      0 },   /* RDR 14 */
  87         { 8,    1,      0 },   /* RDR 15 */
  88         { 1530, 24,     0 },   /* RDR 16 */
  89         { 16,   1,      0 },   /* RDR 17 */
  90         { 4,    1,      0 },   /* RDR 18 */
  91         { 0,    0,      0 },   /* RDR 19 */
  92         { 152,  3,      24 },  /* RDR 20 */
  93         { 152,  3,      24 },  /* RDR 21 */
  94         { 233,  4,      48 },  /* RDR 22 */
  95         { 233,  4,      48 },  /* RDR 23 */
  96         { 71,   2,      0 },   /* RDR 24 */
  97         { 71,   2,      0 },   /* RDR 25 */
  98         { 11,   1,      0 },   /* RDR 26 */
  99         { 18,   1,      0 },   /* RDR 27 */
 100         { 128,  2,      0 },   /* RDR 28 */
 101         { 0,    0,      0 },   /* RDR 29 */
 102         { 16,   1,      0 },   /* RDR 30 */
 103         { 16,   1,      0 },   /* RDR 31 */
 104 };
 105 
 106 /* RDR register descriptions for PCX-U */
 107 static const struct rdr_tbl_ent perf_rdr_tbl_U[] = {
 108         { 19,   1,      8 },              /* RDR 0 */
 109         { 32,   1,      16 },             /* RDR 1 */
 110         { 20,   1,      0 },              /* RDR 2 */
 111         { 0,    0,      0 },              /* RDR 3 */
 112         { 344,  6,      0 },              /* RDR 4 */
 113         { 176,  3,      0 },              /* RDR 5 */
 114         { 336,  6,      0 },              /* RDR 6 */
 115         { 0,    0,      0 },              /* RDR 7 */
 116         { 0,    0,      0 },              /* RDR 8 */
 117         { 0,    0,      0 },              /* RDR 9 */
 118         { 28,   1,      0 },              /* RDR 10 */
 119         { 33,   1,      0 },              /* RDR 11 */
 120         { 0,    0,      0 },              /* RDR 12 */
 121         { 230,  4,      0 },              /* RDR 13 */
 122         { 32,   1,      0 },              /* RDR 14 */
 123         { 128,  2,      0 },              /* RDR 15 */
 124         { 1494, 24,     0 },              /* RDR 16 */
 125         { 18,   1,      0 },              /* RDR 17 */
 126         { 4,    1,      0 },              /* RDR 18 */
 127         { 0,    0,      0 },              /* RDR 19 */
 128         { 158,  3,      24 },             /* RDR 20 */
 129         { 158,  3,      24 },             /* RDR 21 */
 130         { 194,  4,      48 },             /* RDR 22 */
 131         { 194,  4,      48 },             /* RDR 23 */
 132         { 71,   2,      0 },              /* RDR 24 */
 133         { 71,   2,      0 },              /* RDR 25 */
 134         { 28,   1,      0 },              /* RDR 26 */
 135         { 33,   1,      0 },              /* RDR 27 */
 136         { 88,   2,      0 },              /* RDR 28 */
 137         { 32,   1,      0 },              /* RDR 29 */
 138         { 24,   1,      0 },              /* RDR 30 */
 139         { 16,   1,      0 },              /* RDR 31 */
 140 };
 141 
 142 /*
 143  * A non-zero write_control in the above tables is a byte offset into
 144  * this array.
 145  */
 146 static const uint64_t perf_bitmasks[] = {
 147         0x0000000000000000ul,     /* first dbl word must be zero */
 148         0xfdffe00000000000ul,     /* RDR0 bitmask */
 149         0x003f000000000000ul,     /* RDR1 bitmask */
 150         0x00fffffffffffffful,     /* RDR20-RDR21 bitmask (152 bits) */
 151         0xfffffffffffffffful,
 152         0xfffffffc00000000ul,
 153         0xfffffffffffffffful,     /* RDR22-RDR23 bitmask (233 bits) */
 154         0xfffffffffffffffful,
 155         0xfffffffffffffffcul,
 156         0xff00000000000000ul
 157 };
 158 
 159 /*
 160  * Write control bitmasks for Pa-8700 processor given
 161  * some things have changed slightly.
 162  */
 163 static const uint64_t perf_bitmasks_piranha[] = {
 164         0x0000000000000000ul,     /* first dbl word must be zero */
 165         0xfdffe00000000000ul,     /* RDR0 bitmask */
 166         0x003f000000000000ul,     /* RDR1 bitmask */
 167         0x00fffffffffffffful,     /* RDR20-RDR21 bitmask (158 bits) */
 168         0xfffffffffffffffful,
 169         0xfffffffc00000000ul,
 170         0xfffffffffffffffful,     /* RDR22-RDR23 bitmask (210 bits) */
 171         0xfffffffffffffffful,
 172         0xfffffffffffffffful,
 173         0xfffc000000000000ul
 174 };
 175 
 176 static const uint64_t *bitmask_array;   /* array of bitmasks to use */
 177 
 178 /******************************************************************************
 179  * Function Prototypes
 180  *****************************************************************************/
 181 static int perf_config(uint32_t *image_ptr);
 182 static int perf_release(struct inode *inode, struct file *file);
 183 static int perf_open(struct inode *inode, struct file *file);
 184 static ssize_t perf_read(struct file *file, char __user *buf, size_t cnt, loff_t *ppos);
 185 static ssize_t perf_write(struct file *file, const char __user *buf,
 186         size_t count, loff_t *ppos);
 187 static long perf_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
 188 static void perf_start_counters(void);
 189 static int perf_stop_counters(uint32_t *raddr);
 190 static const struct rdr_tbl_ent * perf_rdr_get_entry(uint32_t rdr_num);
 191 static int perf_rdr_read_ubuf(uint32_t  rdr_num, uint64_t *buffer);
 192 static int perf_rdr_clear(uint32_t rdr_num);
 193 static int perf_write_image(uint64_t *memaddr);
 194 static void perf_rdr_write(uint32_t rdr_num, uint64_t *buffer);
 195 
 196 /* External Assembly Routines */
 197 extern uint64_t perf_rdr_shift_in_W (uint32_t rdr_num, uint16_t width);
 198 extern uint64_t perf_rdr_shift_in_U (uint32_t rdr_num, uint16_t width);
 199 extern void perf_rdr_shift_out_W (uint32_t rdr_num, uint64_t buffer);
 200 extern void perf_rdr_shift_out_U (uint32_t rdr_num, uint64_t buffer);
 201 extern void perf_intrigue_enable_perf_counters (void);
 202 extern void perf_intrigue_disable_perf_counters (void);
 203 
 204 /******************************************************************************
 205  * Function Definitions
 206  *****************************************************************************/
 207 
 208 
 209 /*
 210  * configure:
 211  *
 212  * Configure the cpu with a given data image.  First turn off the counters,
 213  * then download the image, then turn the counters back on.
 214  */
 215 static int perf_config(uint32_t *image_ptr)
 216 {
 217         long error;
 218         uint32_t raddr[4];
 219 
 220         /* Stop the counters*/
 221         error = perf_stop_counters(raddr);
 222         if (error != 0) {
 223                 printk("perf_config: perf_stop_counters = %ld\n", error);
 224                 return -EINVAL;
 225         }
 226 
 227 printk("Preparing to write image\n");
 228         /* Write the image to the chip */
 229         error = perf_write_image((uint64_t *)image_ptr);
 230         if (error != 0) {
 231                 printk("perf_config: DOWNLOAD = %ld\n", error);
 232                 return -EINVAL;
 233         }
 234 
 235 printk("Preparing to start counters\n");
 236 
 237         /* Start the counters */
 238         perf_start_counters();
 239 
 240         return sizeof(uint32_t);
 241 }
 242 
 243 /*
 244  * Open the device and initialize all of its memory.  The device is only
 245  * opened once, but can be "queried" by multiple processes that know its
 246  * file descriptor.
 247  */
 248 static int perf_open(struct inode *inode, struct file *file)
 249 {
 250         spin_lock(&perf_lock);
 251         if (perf_enabled) {
 252                 spin_unlock(&perf_lock);
 253                 return -EBUSY;
 254         }
 255         perf_enabled = 1;
 256         spin_unlock(&perf_lock);
 257 
 258         return 0;
 259 }
 260 
 261 /*
 262  * Close the device.
 263  */
 264 static int perf_release(struct inode *inode, struct file *file)
 265 {
 266         spin_lock(&perf_lock);
 267         perf_enabled = 0;
 268         spin_unlock(&perf_lock);
 269 
 270         return 0;
 271 }
 272 
 273 /*
 274  * Read does nothing for this driver
 275  */
 276 static ssize_t perf_read(struct file *file, char __user *buf, size_t cnt, loff_t *ppos)
 277 {
 278         return 0;
 279 }
 280 
 281 /*
 282  * write:
 283  *
 284  * This routine downloads the image to the chip.  It must be
 285  * called on the processor that the download should happen
 286  * on.
 287  */
 288 static ssize_t perf_write(struct file *file, const char __user *buf,
 289         size_t count, loff_t *ppos)
 290 {
 291         size_t image_size;
 292         uint32_t image_type;
 293         uint32_t interface_type;
 294         uint32_t test;
 295 
 296         if (perf_processor_interface == ONYX_INTF)
 297                 image_size = PCXU_IMAGE_SIZE;
 298         else if (perf_processor_interface == CUDA_INTF)
 299                 image_size = PCXW_IMAGE_SIZE;
 300         else
 301                 return -EFAULT;
 302 
 303         if (!capable(CAP_SYS_ADMIN))
 304                 return -EACCES;
 305 
 306         if (count != sizeof(uint32_t))
 307                 return -EIO;
 308 
 309         if (copy_from_user(&image_type, buf, sizeof(uint32_t)))
 310                 return -EFAULT;
 311 
 312         /* Get the interface type and test type */
 313         interface_type = (image_type >> 16) & 0xffff;
 314         test           = (image_type & 0xffff);
 315 
 316         /* Make sure everything makes sense */
 317 
 318         /* First check the machine type is correct for
 319            the requested image */
 320         if (((perf_processor_interface == CUDA_INTF) &&
 321                         (interface_type != CUDA_INTF)) ||
 322                 ((perf_processor_interface == ONYX_INTF) &&
 323                         (interface_type != ONYX_INTF)))
 324                 return -EINVAL;
 325 
 326         /* Next check to make sure the requested image
 327            is valid */
 328         if (((interface_type == CUDA_INTF) &&
 329                        (test >= MAX_CUDA_IMAGES)) ||
 330             ((interface_type == ONYX_INTF) &&
 331                        (test >= MAX_ONYX_IMAGES)))
 332                 return -EINVAL;
 333 
 334         /* Copy the image into the processor */
 335         if (interface_type == CUDA_INTF)
 336                 return perf_config(cuda_images[test]);
 337         else
 338                 return perf_config(onyx_images[test]);
 339 
 340         return count;
 341 }
 342 
 343 /*
 344  * Patch the images that need to know the IVA addresses.
 345  */
 346 static void perf_patch_images(void)
 347 {
 348 #if 0 /* FIXME!! */
 349 /*
 350  * NOTE:  this routine is VERY specific to the current TLB image.
 351  * If the image is changed, this routine might also need to be changed.
 352  */
 353         extern void $i_itlb_miss_2_0();
 354         extern void $i_dtlb_miss_2_0();
 355         extern void PA2_0_iva();
 356 
 357         /*
 358          * We can only use the lower 32-bits, the upper 32-bits should be 0
 359          * anyway given this is in the kernel
 360          */
 361         uint32_t itlb_addr  = (uint32_t)&($i_itlb_miss_2_0);
 362         uint32_t dtlb_addr  = (uint32_t)&($i_dtlb_miss_2_0);
 363         uint32_t IVAaddress = (uint32_t)&PA2_0_iva;
 364 
 365         if (perf_processor_interface == ONYX_INTF) {
 366                 /* clear last 2 bytes */
 367                 onyx_images[TLBMISS][15] &= 0xffffff00;
 368                 /* set 2 bytes */
 369                 onyx_images[TLBMISS][15] |= (0x000000ff&((dtlb_addr) >> 24));
 370                 onyx_images[TLBMISS][16] = (dtlb_addr << 8)&0xffffff00;
 371                 onyx_images[TLBMISS][17] = itlb_addr;
 372 
 373                 /* clear last 2 bytes */
 374                 onyx_images[TLBHANDMISS][15] &= 0xffffff00;
 375                 /* set 2 bytes */
 376                 onyx_images[TLBHANDMISS][15] |= (0x000000ff&((dtlb_addr) >> 24));
 377                 onyx_images[TLBHANDMISS][16] = (dtlb_addr << 8)&0xffffff00;
 378                 onyx_images[TLBHANDMISS][17] = itlb_addr;
 379 
 380                 /* clear last 2 bytes */
 381                 onyx_images[BIG_CPI][15] &= 0xffffff00;
 382                 /* set 2 bytes */
 383                 onyx_images[BIG_CPI][15] |= (0x000000ff&((dtlb_addr) >> 24));
 384                 onyx_images[BIG_CPI][16] = (dtlb_addr << 8)&0xffffff00;
 385                 onyx_images[BIG_CPI][17] = itlb_addr;
 386 
 387             onyx_images[PANIC][15] &= 0xffffff00;  /* clear last 2 bytes */
 388                 onyx_images[PANIC][15] |= (0x000000ff&((IVAaddress) >> 24)); /* set 2 bytes */
 389                 onyx_images[PANIC][16] = (IVAaddress << 8)&0xffffff00;
 390 
 391 
 392         } else if (perf_processor_interface == CUDA_INTF) {
 393                 /* Cuda interface */
 394                 cuda_images[TLBMISS][16] =
 395                         (cuda_images[TLBMISS][16]&0xffff0000) |
 396                         ((dtlb_addr >> 8)&0x0000ffff);
 397                 cuda_images[TLBMISS][17] =
 398                         ((dtlb_addr << 24)&0xff000000) | ((itlb_addr >> 16)&0x000000ff);
 399                 cuda_images[TLBMISS][18] = (itlb_addr << 16)&0xffff0000;
 400 
 401                 cuda_images[TLBHANDMISS][16] =
 402                         (cuda_images[TLBHANDMISS][16]&0xffff0000) |
 403                         ((dtlb_addr >> 8)&0x0000ffff);
 404                 cuda_images[TLBHANDMISS][17] =
 405                         ((dtlb_addr << 24)&0xff000000) | ((itlb_addr >> 16)&0x000000ff);
 406                 cuda_images[TLBHANDMISS][18] = (itlb_addr << 16)&0xffff0000;
 407 
 408                 cuda_images[BIG_CPI][16] =
 409                         (cuda_images[BIG_CPI][16]&0xffff0000) |
 410                         ((dtlb_addr >> 8)&0x0000ffff);
 411                 cuda_images[BIG_CPI][17] =
 412                         ((dtlb_addr << 24)&0xff000000) | ((itlb_addr >> 16)&0x000000ff);
 413                 cuda_images[BIG_CPI][18] = (itlb_addr << 16)&0xffff0000;
 414         } else {
 415                 /* Unknown type */
 416         }
 417 #endif
 418 }
 419 
 420 
 421 /*
 422  * ioctl routine
 423  * All routines effect the processor that they are executed on.  Thus you
 424  * must be running on the processor that you wish to change.
 425  */
 426 
 427 static long perf_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 428 {
 429         long error_start;
 430         uint32_t raddr[4];
 431         int error = 0;
 432 
 433         switch (cmd) {
 434 
 435             case PA_PERF_ON:
 436                         /* Start the counters */
 437                         perf_start_counters();
 438                         break;
 439 
 440             case PA_PERF_OFF:
 441                         error_start = perf_stop_counters(raddr);
 442                         if (error_start != 0) {
 443                                 printk(KERN_ERR "perf_off: perf_stop_counters = %ld\n", error_start);
 444                                 error = -EFAULT;
 445                                 break;
 446                         }
 447 
 448                         /* copy out the Counters */
 449                         if (copy_to_user((void __user *)arg, raddr,
 450                                         sizeof (raddr)) != 0) {
 451                                 error =  -EFAULT;
 452                                 break;
 453                         }
 454                         break;
 455 
 456             case PA_PERF_VERSION:
 457                         /* Return the version # */
 458                         error = put_user(PERF_VERSION, (int *)arg);
 459                         break;
 460 
 461             default:
 462                         error = -ENOTTY;
 463         }
 464 
 465         return error;
 466 }
 467 
 468 static const struct file_operations perf_fops = {
 469         .llseek = no_llseek,
 470         .read = perf_read,
 471         .write = perf_write,
 472         .unlocked_ioctl = perf_ioctl,
 473         .compat_ioctl = perf_ioctl,
 474         .open = perf_open,
 475         .release = perf_release
 476 };
 477 
 478 static struct miscdevice perf_dev = {
 479         MISC_DYNAMIC_MINOR,
 480         PA_PERF_DEV,
 481         &perf_fops
 482 };
 483 
 484 /*
 485  * Initialize the module
 486  */
 487 static int __init perf_init(void)
 488 {
 489         int ret;
 490 
 491         /* Determine correct processor interface to use */
 492         bitmask_array = perf_bitmasks;
 493 
 494         if (boot_cpu_data.cpu_type == pcxu ||
 495             boot_cpu_data.cpu_type == pcxu_) {
 496                 perf_processor_interface = ONYX_INTF;
 497         } else if (boot_cpu_data.cpu_type == pcxw ||
 498                  boot_cpu_data.cpu_type == pcxw_ ||
 499                  boot_cpu_data.cpu_type == pcxw2 ||
 500                  boot_cpu_data.cpu_type == mako ||
 501                  boot_cpu_data.cpu_type == mako2) {
 502                 perf_processor_interface = CUDA_INTF;
 503                 if (boot_cpu_data.cpu_type == pcxw2 ||
 504                     boot_cpu_data.cpu_type == mako ||
 505                     boot_cpu_data.cpu_type == mako2)
 506                         bitmask_array = perf_bitmasks_piranha;
 507         } else {
 508                 perf_processor_interface = UNKNOWN_INTF;
 509                 printk("Performance monitoring counters not supported on this processor\n");
 510                 return -ENODEV;
 511         }
 512 
 513         ret = misc_register(&perf_dev);
 514         if (ret) {
 515                 printk(KERN_ERR "Performance monitoring counters: "
 516                         "cannot register misc device.\n");
 517                 return ret;
 518         }
 519 
 520         /* Patch the images to match the system */
 521         perf_patch_images();
 522 
 523         /* TODO: this only lets us access the first cpu.. what to do for SMP? */
 524         cpu_device = per_cpu(cpu_data, 0).dev;
 525         printk("Performance monitoring counters enabled for %s\n",
 526                 per_cpu(cpu_data, 0).dev->name);
 527 
 528         return 0;
 529 }
 530 device_initcall(perf_init);
 531 
 532 /*
 533  * perf_start_counters(void)
 534  *
 535  * Start the counters.
 536  */
 537 static void perf_start_counters(void)
 538 {
 539         /* Enable performance monitor counters */
 540         perf_intrigue_enable_perf_counters();
 541 }
 542 
 543 /*
 544  * perf_stop_counters
 545  *
 546  * Stop the performance counters and save counts
 547  * in a per_processor array.
 548  */
 549 static int perf_stop_counters(uint32_t *raddr)
 550 {
 551         uint64_t userbuf[MAX_RDR_WORDS];
 552 
 553         /* Disable performance counters */
 554         perf_intrigue_disable_perf_counters();
 555 
 556         if (perf_processor_interface == ONYX_INTF) {
 557                 uint64_t tmp64;
 558                 /*
 559                  * Read the counters
 560                  */
 561                 if (!perf_rdr_read_ubuf(16, userbuf))
 562                         return -13;
 563 
 564                 /* Counter0 is bits 1398 to 1429 */
 565                 tmp64 =  (userbuf[21] << 22) & 0x00000000ffc00000;
 566                 tmp64 |= (userbuf[22] >> 42) & 0x00000000003fffff;
 567                 /* OR sticky0 (bit 1430) to counter0 bit 32 */
 568                 tmp64 |= (userbuf[22] >> 10) & 0x0000000080000000;
 569                 raddr[0] = (uint32_t)tmp64;
 570 
 571                 /* Counter1 is bits 1431 to 1462 */
 572                 tmp64 =  (userbuf[22] >> 9) & 0x00000000ffffffff;
 573                 /* OR sticky1 (bit 1463) to counter1 bit 32 */
 574                 tmp64 |= (userbuf[22] << 23) & 0x0000000080000000;
 575                 raddr[1] = (uint32_t)tmp64;
 576 
 577                 /* Counter2 is bits 1464 to 1495 */
 578                 tmp64 =  (userbuf[22] << 24) & 0x00000000ff000000;
 579                 tmp64 |= (userbuf[23] >> 40) & 0x0000000000ffffff;
 580                 /* OR sticky2 (bit 1496) to counter2 bit 32 */
 581                 tmp64 |= (userbuf[23] >> 8) & 0x0000000080000000;
 582                 raddr[2] = (uint32_t)tmp64;
 583 
 584                 /* Counter3 is bits 1497 to 1528 */
 585                 tmp64 =  (userbuf[23] >> 7) & 0x00000000ffffffff;
 586                 /* OR sticky3 (bit 1529) to counter3 bit 32 */
 587                 tmp64 |= (userbuf[23] << 25) & 0x0000000080000000;
 588                 raddr[3] = (uint32_t)tmp64;
 589 
 590                 /*
 591                  * Zero out the counters
 592                  */
 593 
 594                 /*
 595                  * The counters and sticky-bits comprise the last 132 bits
 596                  * (1398 - 1529) of RDR16 on a U chip.  We'll zero these
 597                  * out the easy way: zero out last 10 bits of dword 21,
 598                  * all of dword 22 and 58 bits (plus 6 don't care bits) of
 599                  * dword 23.
 600                  */
 601                 userbuf[21] &= 0xfffffffffffffc00ul;    /* 0 to last 10 bits */
 602                 userbuf[22] = 0;
 603                 userbuf[23] = 0;
 604 
 605                 /*
 606                  * Write back the zeroed bytes + the image given
 607                  * the read was destructive.
 608                  */
 609                 perf_rdr_write(16, userbuf);
 610         } else {
 611 
 612                 /*
 613                  * Read RDR-15 which contains the counters and sticky bits
 614                  */
 615                 if (!perf_rdr_read_ubuf(15, userbuf)) {
 616                         return -13;
 617                 }
 618 
 619                 /*
 620                  * Clear out the counters
 621                  */
 622                 perf_rdr_clear(15);
 623 
 624                 /*
 625                  * Copy the counters 
 626                  */
 627                 raddr[0] = (uint32_t)((userbuf[0] >> 32) & 0x00000000ffffffffUL);
 628                 raddr[1] = (uint32_t)(userbuf[0] & 0x00000000ffffffffUL);
 629                 raddr[2] = (uint32_t)((userbuf[1] >> 32) & 0x00000000ffffffffUL);
 630                 raddr[3] = (uint32_t)(userbuf[1] & 0x00000000ffffffffUL);
 631         }
 632 
 633         return 0;
 634 }
 635 
 636 /*
 637  * perf_rdr_get_entry
 638  *
 639  * Retrieve a pointer to the description of what this
 640  * RDR contains.
 641  */
 642 static const struct rdr_tbl_ent * perf_rdr_get_entry(uint32_t rdr_num)
 643 {
 644         if (perf_processor_interface == ONYX_INTF) {
 645                 return &perf_rdr_tbl_U[rdr_num];
 646         } else {
 647                 return &perf_rdr_tbl_W[rdr_num];
 648         }
 649 }
 650 
 651 /*
 652  * perf_rdr_read_ubuf
 653  *
 654  * Read the RDR value into the buffer specified.
 655  */
 656 static int perf_rdr_read_ubuf(uint32_t  rdr_num, uint64_t *buffer)
 657 {
 658         uint64_t        data, data_mask = 0;
 659         uint32_t        width, xbits, i;
 660         const struct rdr_tbl_ent *tentry;
 661 
 662         tentry = perf_rdr_get_entry(rdr_num);
 663         if ((width = tentry->width) == 0)
 664                 return 0;
 665 
 666         /* Clear out buffer */
 667         i = tentry->num_words;
 668         while (i--) {
 669                 buffer[i] = 0;
 670         }
 671 
 672         /* Check for bits an even number of 64 */
 673         if ((xbits = width & 0x03f) != 0) {
 674                 data_mask = 1;
 675                 data_mask <<= (64 - xbits);
 676                 data_mask--;
 677         }
 678 
 679         /* Grab all of the data */
 680         i = tentry->num_words;
 681         while (i--) {
 682 
 683                 if (perf_processor_interface == ONYX_INTF) {
 684                         data = perf_rdr_shift_in_U(rdr_num, width);
 685                 } else {
 686                         data = perf_rdr_shift_in_W(rdr_num, width);
 687                 }
 688                 if (xbits) {
 689                         buffer[i] |= (data << (64 - xbits));
 690                         if (i) {
 691                                 buffer[i-1] |= ((data >> xbits) & data_mask);
 692                         }
 693                 } else {
 694                         buffer[i] = data;
 695                 }
 696         }
 697 
 698         return 1;
 699 }
 700 
 701 /*
 702  * perf_rdr_clear
 703  *
 704  * Zero out the given RDR register
 705  */
 706 static int perf_rdr_clear(uint32_t      rdr_num)
 707 {
 708         const struct rdr_tbl_ent *tentry;
 709         int32_t         i;
 710 
 711         tentry = perf_rdr_get_entry(rdr_num);
 712 
 713         if (tentry->width == 0) {
 714                 return -1;
 715         }
 716 
 717         i = tentry->num_words;
 718         while (i--) {
 719                 if (perf_processor_interface == ONYX_INTF) {
 720                         perf_rdr_shift_out_U(rdr_num, 0UL);
 721                 } else {
 722                         perf_rdr_shift_out_W(rdr_num, 0UL);
 723                 }
 724         }
 725 
 726         return 0;
 727 }
 728 
 729 
 730 /*
 731  * perf_write_image
 732  *
 733  * Write the given image out to the processor
 734  */
 735 static int perf_write_image(uint64_t *memaddr)
 736 {
 737         uint64_t buffer[MAX_RDR_WORDS];
 738         uint64_t *bptr;
 739         uint32_t dwords;
 740         const uint32_t *intrigue_rdr;
 741         const uint64_t *intrigue_bitmask;
 742         uint64_t tmp64;
 743         void __iomem *runway;
 744         const struct rdr_tbl_ent *tentry;
 745         int i;
 746 
 747         /* Clear out counters */
 748         if (perf_processor_interface == ONYX_INTF) {
 749 
 750                 perf_rdr_clear(16);
 751 
 752                 /* Toggle performance monitor */
 753                 perf_intrigue_enable_perf_counters();
 754                 perf_intrigue_disable_perf_counters();
 755 
 756                 intrigue_rdr = perf_rdrs_U;
 757         } else {
 758                 perf_rdr_clear(15);
 759                 intrigue_rdr = perf_rdrs_W;
 760         }
 761 
 762         /* Write all RDRs */
 763         while (*intrigue_rdr != -1) {
 764                 tentry = perf_rdr_get_entry(*intrigue_rdr);
 765                 perf_rdr_read_ubuf(*intrigue_rdr, buffer);
 766                 bptr   = &buffer[0];
 767                 dwords = tentry->num_words;
 768                 if (tentry->write_control) {
 769                         intrigue_bitmask = &bitmask_array[tentry->write_control >> 3];
 770                         while (dwords--) {
 771                                 tmp64 = *intrigue_bitmask & *memaddr++;
 772                                 tmp64 |= (~(*intrigue_bitmask++)) & *bptr;
 773                                 *bptr++ = tmp64;
 774                         }
 775                 } else {
 776                         while (dwords--) {
 777                                 *bptr++ = *memaddr++;
 778                         }
 779                 }
 780 
 781                 perf_rdr_write(*intrigue_rdr, buffer);
 782                 intrigue_rdr++;
 783         }
 784 
 785         /*
 786          * Now copy out the Runway stuff which is not in RDRs
 787          */
 788 
 789         if (cpu_device == NULL)
 790         {
 791                 printk(KERN_ERR "write_image: cpu_device not yet initialized!\n");
 792                 return -1;
 793         }
 794 
 795         runway = ioremap_nocache(cpu_device->hpa.start, 4096);
 796         if (!runway) {
 797                 pr_err("perf_write_image: ioremap failed!\n");
 798                 return -ENOMEM;
 799         }
 800 
 801         /* Merge intrigue bits into Runway STATUS 0 */
 802         tmp64 = __raw_readq(runway + RUNWAY_STATUS) & 0xffecfffffffffffful;
 803         __raw_writeq(tmp64 | (*memaddr++ & 0x0013000000000000ul),
 804                      runway + RUNWAY_STATUS);
 805 
 806         /* Write RUNWAY DEBUG registers */
 807         for (i = 0; i < 8; i++) {
 808                 __raw_writeq(*memaddr++, runway + RUNWAY_DEBUG);
 809         }
 810 
 811         return 0;
 812 }
 813 
 814 /*
 815  * perf_rdr_write
 816  *
 817  * Write the given RDR register with the contents
 818  * of the given buffer.
 819  */
 820 static void perf_rdr_write(uint32_t rdr_num, uint64_t *buffer)
 821 {
 822         const struct rdr_tbl_ent *tentry;
 823         int32_t         i;
 824 
 825 printk("perf_rdr_write\n");
 826         tentry = perf_rdr_get_entry(rdr_num);
 827         if (tentry->width == 0) { return; }
 828 
 829         i = tentry->num_words;
 830         while (i--) {
 831                 if (perf_processor_interface == ONYX_INTF) {
 832                         perf_rdr_shift_out_U(rdr_num, buffer[i]);
 833                 } else {
 834                         perf_rdr_shift_out_W(rdr_num, buffer[i]);
 835                 }
 836         }
 837 printk("perf_rdr_write done\n");
 838 }