开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
perf.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：22k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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