source: rtems/bsps/sparc/shared/stat/l4stat.c @ 31720925

Last change on this file since 31720925 was 31720925, checked in by Sebastian Huber <sebastian.huber@…>, on Dec 22, 2018 at 6:13:44 AM

grlib: Move header files

Update #3678.

  • Property mode set to 100644
File size: 16.3 KB
Line 
1/* L4STAT APB-Register Driver.
2 *
3 * COPYRIGHT (c) 2017.
4 * Cobham Gaisler AB.
5 *
6 * The license and distribution terms for this file may be
7 * found in the file LICENSE in this distribution or at
8 * http://www.rtems.org/license/LICENSE.
9 */
10
11#include <rtems.h>
12#include <rtems/libio.h>
13#include <stdio.h>
14#include <bsp.h>
15#include <rtems/bspIo.h> /* printk */
16
17#include <drvmgr/drvmgr.h>
18#include <grlib/ambapp_bus.h>
19#include <grlib/l4stat.h>
20
21/*#define STATIC*/
22#define STATIC static
23
24/*#define DEBUG 1*/
25
26#ifdef DEBUG
27#define DBG(x...) printf(x)
28#else
29#define DBG(x...)
30#endif
31
32#define REG_WRITE(addr, val) (*(volatile unsigned int *)(addr) = (unsigned int)(val))
33#define REG_READ(addr) (*(volatile unsigned int *)(addr))
34
35
36/*
37 * L4STAT CCTRL register fields
38 * DEFINED IN HEADER file
39 */
40
41struct l4stat_regs {
42        unsigned int cval[32];                          /* 0x000 */
43        unsigned int cctrl[32];                         /* 0x080 */
44        unsigned int cmax[32];                          /* 0x100 */
45        unsigned int timestamp;                         /* 0x180 */
46};
47
48struct l4stat_priv {
49        struct drvmgr_dev *dev;
50
51        /* L4STAT control registers */
52        struct l4stat_regs *regs;
53
54        /* L4STAT driver register */
55        char devname[9];
56
57        int ncpu;
58        int ncnt;
59
60        /* L4stat capabilities */
61        int max_count_support;
62        int internalahb_event_support;
63        int dsu_event_support;
64        int external_event_support;
65        int ahbtrace_event_support;
66};
67
68STATIC struct l4stat_priv *l4statpriv = NULL;
69
70/* Event names */
71#ifdef DEBUG
72#define L4STAT_BAD_CMD "N/A. Wrong event"
73STATIC const char *l4stat_event_names[] = {
74        "Instruction cache miss",                               /* 0x00 */
75        "Instruction MMU TLB miss",                             /* 0x01 */
76        "Instruction cache hold",                               /* 0x02 */
77        "Instruction MMU hold",                                 /* 0x03 */
78        L4STAT_BAD_CMD,                                         /* 0x04 */
79        L4STAT_BAD_CMD,                                         /* 0x05 */
80        L4STAT_BAD_CMD,                                         /* 0x06 */
81        L4STAT_BAD_CMD,                                         /* 0x07 */
82        "Data cache (read) miss",                               /* 0x08 */
83        "Data MMU TLB miss",                                    /* 0x09 */
84        "Data cache hold",                                      /* 0x0a */
85        "Data MMU hold",                                        /* 0x0b */
86        L4STAT_BAD_CMD,                                         /* 0x0c */
87        L4STAT_BAD_CMD,                                         /* 0x0d */
88        L4STAT_BAD_CMD,                                         /* 0x0e */
89        L4STAT_BAD_CMD,                                         /* 0x0f */
90        "Data write buffer hold",                               /* 0x10 */
91        "Total instruction count",                              /* 0x11 */
92        "Integer instruction count",                            /* 0x12 */
93        "Floating-point unit instruction count",                /* 0x13 */
94        "Branch prediction miss",                               /* 0x14 */
95        "Execution time, exluding debug mode",                  /* 0x15 */
96        L4STAT_BAD_CMD,                                         /* 0x16 */
97        "AHB utilization (per AHB master)",                     /* 0x17 */
98        "AHB utilization (total)",                              /* 0x18 */
99        L4STAT_BAD_CMD,                                         /* 0x19 */
100        L4STAT_BAD_CMD,                                         /* 0x1a */
101        L4STAT_BAD_CMD,                                         /* 0x1b */
102        L4STAT_BAD_CMD,                                         /* 0x1c */
103        L4STAT_BAD_CMD,                                         /* 0x1d */
104        L4STAT_BAD_CMD,                                         /* 0x1e */
105        L4STAT_BAD_CMD,                                         /* 0x1f */
106        L4STAT_BAD_CMD,                                         /* 0x20 */
107        L4STAT_BAD_CMD,                                         /* 0x21 */
108        "Integer branches",                                     /* 0x22 */
109        L4STAT_BAD_CMD,                                         /* 0x23 */
110        L4STAT_BAD_CMD,                                         /* 0x24 */
111        L4STAT_BAD_CMD,                                         /* 0x25 */
112        L4STAT_BAD_CMD,                                         /* 0x26 */
113        L4STAT_BAD_CMD,                                         /* 0x27 */
114        "CALL instructions",                                    /* 0x28 */
115        L4STAT_BAD_CMD,                                         /* 0x29 */
116        L4STAT_BAD_CMD,                                         /* 0x2a */
117        L4STAT_BAD_CMD,                                         /* 0x2b */
118        L4STAT_BAD_CMD,                                         /* 0x2c */
119        L4STAT_BAD_CMD,                                         /* 0x2d */
120        L4STAT_BAD_CMD,                                         /* 0x2e */
121        L4STAT_BAD_CMD,                                         /* 0x2f */
122        "Regular type 2 instructions",                          /* 0x30 */
123        L4STAT_BAD_CMD,                                         /* 0x31 */
124        L4STAT_BAD_CMD,                                         /* 0x32 */
125        L4STAT_BAD_CMD,                                         /* 0x33 */
126        L4STAT_BAD_CMD,                                         /* 0x34 */
127        L4STAT_BAD_CMD,                                         /* 0x35 */
128        L4STAT_BAD_CMD,                                         /* 0x36 */
129        L4STAT_BAD_CMD,                                         /* 0x37 */
130        "LOAD and STORE instructions",                          /* 0x38 */
131        "LOAD instructions",                                    /* 0x39 */
132        "STORE instructions",                                   /* 0x3a */
133        L4STAT_BAD_CMD,                                         /* 0x3b */
134        L4STAT_BAD_CMD,                                         /* 0x3c */
135        L4STAT_BAD_CMD,                                         /* 0x3d */
136        L4STAT_BAD_CMD,                                         /* 0x3e */
137        L4STAT_BAD_CMD,                                         /* 0x3f */
138        "AHB IDLE cycles",                                      /* 0x40 */
139        "AHB BUSY cycles",                                      /* 0x41 */
140        "AHB Non-Seq. transfers",                               /* 0x42 */
141        "AHB Seq. transfers",                                   /* 0x43 */
142        "AHB read accesses",                                    /* 0x44 */
143        "AHB write accesses",                                   /* 0x45 */
144        "AHB byte accesses",                                    /* 0x46 */
145        "AHB half-word accesses",                               /* 0x47 */
146        "AHB word accesses",                                    /* 0x48 */
147        "AHB double word accesses",                             /* 0x49 */
148        "AHB quad word accesses",                               /* 0x4A */
149        "AHB eight word accesses",                              /* 0x4B */
150        "AHB waitstates",                                       /* 0x4C */
151        "AHB RETRY responses",                                  /* 0x4D */
152        "AHB SPLIT responses",                                  /* 0x4E */
153        "AHB SPLIT delay",                                      /* 0x4F */
154        "AHB bus locked",                                       /* 0x50 */
155        L4STAT_BAD_CMD,                                         /* 0x51 */
156        L4STAT_BAD_CMD,                                         /* 0x52 */
157        L4STAT_BAD_CMD,                                         /* 0x53 */
158        L4STAT_BAD_CMD,                                         /* 0x54 */
159        L4STAT_BAD_CMD,                                         /* 0x55 */
160        L4STAT_BAD_CMD,                                         /* 0x56 */
161        L4STAT_BAD_CMD,                                         /* 0x57 */
162        L4STAT_BAD_CMD,                                         /* 0x58 */
163        L4STAT_BAD_CMD,                                         /* 0x59 */
164        L4STAT_BAD_CMD,                                         /* 0x5a */
165        L4STAT_BAD_CMD,                                         /* 0x5b */
166        L4STAT_BAD_CMD,                                         /* 0x5c */
167        L4STAT_BAD_CMD,                                         /* 0x5d */
168        L4STAT_BAD_CMD,                                         /* 0x5e */
169        L4STAT_BAD_CMD,                                         /* 0x5f */
170        "external event 0",                                     /* 0x60 */
171        "external event 1",                                     /* 0x61 */
172        "external event 2",                                     /* 0x62 */
173        "external event 3",                                     /* 0x63 */
174        "external event 4",                                     /* 0x64 */
175        "external event 5",                                     /* 0x65 */
176        "external event 6",                                     /* 0x66 */
177        "external event 7",                                     /* 0x67 */
178        "external event 8",                                     /* 0x68 */
179        "external event 9",                                     /* 0x69 */
180        "external event 10",                                    /* 0x6A */
181        "external event 11",                                    /* 0x6B */
182        "external event 12",                                    /* 0x6C */
183        "external event 13",                                    /* 0x6D */
184        "external event 14",                                    /* 0x6E */
185        "external event 15",                                    /* 0x6F */
186        "AHB IDLE cycles (2)",                                  /* 0x70 */
187        "AHB BUSY cycles (2)",                                  /* 0x71 */
188        "AHB Non-Seq. transfers (2)",                           /* 0x72 */
189        "AHB Seq. transfers (2)",                               /* 0x73 */
190        "AHB read accesses (2)",                                /* 0x74 */
191        "AHB write accesses (2)",                               /* 0x75 */
192        "AHB byte accesses (2)",                                /* 0x76 */
193        "AHB half-word accesses (2)",                           /* 0x77 */
194        "AHB word accesses (2)",                                /* 0x78 */
195        "AHB double word accesses (2)",                         /* 0x79 */
196        "AHB quad word accesses (2)",                           /* 0x7A */
197        "AHB eight word accesses (2)",                          /* 0x7B */
198        "AHB waitstates (2)",                                   /* 0x7C */
199        "AHB RETRY responses (2)",                              /* 0x7D */
200        "AHB SPLIT responses (2)",                              /* 0x7E */
201        "AHB SPLIT delay (2)",                                  /* 0x7F */
202        "PMC: master 0 has grant",                              /* 0x80 */
203        "PMC: master 1 has grant",                              /* 0x81 */
204        "PMC: master 2 has grant",                              /* 0x82 */
205        "PMC: master 3 has grant",                              /* 0x83 */
206        "PMC: master 4 has grant",                              /* 0x84 */
207        "PMC: master 5 has grant",                              /* 0x85 */
208        "PMC: master 6 has grant",                              /* 0x86 */
209        "PMC: master 7 has grant",                              /* 0x87 */
210        "PMC: master 8 has grant",                              /* 0x88 */
211        "PMC: master 9 has grant",                              /* 0x89 */
212        "PMC: master 10 has grant",                             /* 0x8A */
213        "PMC: master 11 has grant",                             /* 0x8B */
214        "PMC: master 12 has grant",                             /* 0x8C */
215        "PMC: master 13 has grant",                             /* 0x8D */
216        "PMC: master 14 has grant",                             /* 0x8E */
217        "PMC: master 15 has grant",                             /* 0x8F */
218        "PMC: master 0 lacks grant",                            /* 0x90 */
219        "PMC: master 1 lacks grant",                            /* 0x91 */
220        "PMC: master 2 lacks grant",                            /* 0x92 */
221        "PMC: master 3 lacks grant",                            /* 0x93 */
222        "PMC: master 4 lacks grant",                            /* 0x94 */
223        "PMC: master 5 lacks grant",                            /* 0x95 */
224        "PMC: master 6 lacks grant",                            /* 0x96 */
225        "PMC: master 7 lacks grant",                            /* 0x97 */
226        "PMC: master 8 lacks grant",                            /* 0x98 */
227        "PMC: master 9 lacks grant",                            /* 0x99 */
228        "PMC: master 10 lacks grant",                           /* 0x9A */
229        "PMC: master 11 lacks grant",                           /* 0x9B */
230        "PMC: master 12 lacks grant",                           /* 0x9C */
231        "PMC: master 13 lacks grant",                           /* 0x9D */
232        "PMC: master 14 lacks grant",                           /* 0x9E */
233        "PMC: master 15 lacks grant",                           /* 0x9F */
234        ""
235};
236#endif /* DEBUG */
237
238/* Driver prototypes */
239
240STATIC int l4stat_init(struct l4stat_priv *priv);
241
242int l4stat_init1(struct drvmgr_dev *dev);
243
244struct drvmgr_drv_ops l4stat_ops = 
245{
246        .init = {l4stat_init1, NULL, NULL, NULL},
247        .remove = NULL,
248        .info = NULL
249};
250
251struct amba_dev_id l4stat_ids[] = 
252{
253        {VENDOR_GAISLER, GAISLER_L4STAT},
254        {VENDOR_GAISLER, GAISLER_L3STAT},
255        {0, 0}          /* Mark end of table */
256};
257
258struct amba_drv_info l4stat_drv_info =
259{
260        {
261                DRVMGR_OBJ_DRV,                 /* Driver */
262                NULL,                           /* Next driver */
263                NULL,                           /* Device list */
264                DRIVER_AMBAPP_GAISLER_L4STAT_ID,/* Driver ID */
265                "L4STAT_DRV",                   /* Driver Name */
266                DRVMGR_BUS_TYPE_AMBAPP,         /* Bus Type */
267                &l4stat_ops,
268                NULL,                           /* Funcs */
269                0,                              /* No devices yet */
270                sizeof(struct l4stat_priv),     /* Let DRVMGR allocate for us */
271        },
272        &l4stat_ids[0],
273};
274
275void l4stat_register_drv (void)
276{
277        DBG("Registering L4STAT driver\n");
278        drvmgr_drv_register(&l4stat_drv_info.general);
279}
280
281STATIC int l4stat_init(struct l4stat_priv *priv)
282{
283        struct ambapp_apb_info *apb;
284        struct amba_dev_info *ainfo = priv->dev->businfo;
285        unsigned int tmp;
286        unsigned short dev_id;
287
288        /* Find L4STAT core from Plug&Play information */
289        apb = ainfo->info.apb_slv;
290
291        /* Check if L4STAT or L3STAT core from Plug&Play information */
292        dev_id = ainfo->id.device;
293
294        /* Check if rev 1 of core (only rev 0 supported) */
295        if (apb->ver != 0) {
296                DBG("L4STAT rev 0 only supported.\n");
297                return L4STAT_ERR_ERROR;
298        }
299
300        /* Found L4STAT core, init private structure */
301        priv->regs = (struct l4stat_regs *)apb->start;
302
303        DBG("L4STAT regs 0x%08x\n", (unsigned int) priv->regs);
304
305        /* Find L4STAT capabilities */
306        tmp = REG_READ(&priv->regs->cctrl[0]);
307        /* The CPU field in the register is just information of the
308         * cpus that are connected to the stat unit, but it is not
309         * really used for anything else. I can still have more masters
310         * on the bus (e.g. IOMMU) that I can collect stats from,
311         * so it makes no sense to limit the cpus to the actual cpus.
312         * Therefore, I will take the maximum number as 16. */
313        /*priv->ncpu = ((tmp & CCTRL_NCPU) >> CCTRL_NCPU_BIT) + 1;*/
314        priv->ncpu = 16;
315        if (dev_id == GAISLER_L3STAT) {
316                priv->ncnt = ((tmp & CCTRL_NCNT_L3STAT) >> CCTRL_NCNT_BIT) + 1;
317        }else{
318                priv->ncnt = ((tmp & CCTRL_NCNT) >> CCTRL_NCNT_BIT) + 1;
319        }
320        priv->max_count_support = (tmp & CCTRL_MC) >> CCTRL_MC_BIT;
321        priv->internalahb_event_support = (tmp & CCTRL_IA) >> CCTRL_IA_BIT;
322        priv->dsu_event_support = (tmp & CCTRL_DS) >> CCTRL_DS_BIT;
323        priv->external_event_support = (tmp & CCTRL_EE) >> CCTRL_EE_BIT;
324        priv->ahbtrace_event_support = (tmp & CCTRL_AE) >> CCTRL_AE_BIT;
325
326        /* DEBUG print */
327        DBG("L4STAT with following capabilities:\n");
328        DBG(" -NCPU: %d, NCNT: %d, MaxCNT: %s\n", priv->ncpu, priv->ncnt, 
329                        (priv->max_count_support?"Available":"N/A"));
330        DBG(" -Events= InternalAHB: %s, DSU: %s, External: %s, AHBTRACE: %s\n",
331                        (priv->internalahb_event_support?"Available":"N/A"),
332                        (priv->dsu_event_support?"Available":"N/A"),
333                        (priv->external_event_support?"Available":"N/A"),
334                        (priv->ahbtrace_event_support?"Available":"N/A"));
335
336        return L4STAT_ERR_OK;
337}
338
339int l4stat_init1(struct drvmgr_dev *dev)
340{
341        struct l4stat_priv *priv = dev->priv;
342
343        DBG("L4STAT[%d] on bus %s\n", dev->minor_drv, dev->parent->dev->name);
344
345        if (l4statpriv) {
346                DBG("Driver only supports one L4STAT core\n");
347                return DRVMGR_FAIL;
348        }
349
350        if (priv == NULL) {
351                return DRVMGR_NOMEM;
352        }
353        priv->dev = dev;
354        l4statpriv = priv;
355
356        /* Initilize driver struct */
357        if (l4stat_init(priv) != L4STAT_ERR_OK) {
358                return DRVMGR_FAIL;
359        }
360
361        /* Startup Action:
362         *      - None
363         */
364
365        /* Device name */
366        sprintf(priv->devname, "l4stat0");
367
368        return DRVMGR_OK;
369}
370
371int l4stat_counter_enable(unsigned int counter, int event, int cpu, int options)
372{
373        struct l4stat_priv *priv = l4statpriv;
374        unsigned int ctrl;
375
376        if (priv == NULL) {
377                DBG("L4STAT Device not initialized\n");
378                return L4STAT_ERR_EINVAL;
379        }
380
381        if (counter >= priv->ncnt) {
382                DBG("L4STAT Wrong counter\n");
383                return L4STAT_ERR_EINVAL;
384        }
385
386        if ((cpu < 0) || (cpu >= priv->ncpu)) {
387                DBG("L4STAT Wrong cpu\n");
388                return L4STAT_ERR_EINVAL;
389        }
390
391        if ((options & L4STAT_OPTIONS_MAXIMUM_DURATION) || 
392                        (options & L4STAT_OPTIONS_EVENT_LEVEL_ENABLE)) {
393                if (priv->max_count_support == 0) {
394                        DBG("L4STAT maximum duration count not supported\n");
395                        return L4STAT_ERR_IMPLEMENTED;
396                }
397        }
398
399        /* Check event is supported */
400        if ((event < 0) || (event >= 0x80)) {
401                DBG("L4STAT Wrong event\n");
402                return L4STAT_ERR_EINVAL;
403        }
404        if ((event == 0x18) || (event == 0x17)) {
405                if (priv->internalahb_event_support == 0) {
406                        DBG("L4STAT internal ahb event not supported\n");
407                        return L4STAT_ERR_IMPLEMENTED;
408                }
409        }
410        if ((event >= 0x40) && (event < 0x60)) {
411                if (priv->dsu_event_support == 0) {
412                        DBG("L4STAT dsu event not supported\n");
413                        return L4STAT_ERR_IMPLEMENTED;
414                }
415        }
416        if ((event >= 0x60) && (event < 0x70)) {
417                if (priv->external_event_support == 0) {
418                        DBG("L4STAT external event not supported\n");
419                        return L4STAT_ERR_IMPLEMENTED;
420                }
421        }
422        if ((event >= 0x70) && (event < 0x80)) {
423                if (priv->ahbtrace_event_support == 0) {
424                        DBG("L4STAT ahbtrace event not supported\n");
425                        return L4STAT_ERR_IMPLEMENTED;
426                }
427        }
428
429        /* Prepare counter control */
430        ctrl = (options & ~(CCTRL_EVENTID | CCTRL_CPUAHBM));
431        /* Put event id */
432        ctrl = (ctrl | ((event << CCTRL_EVENTID_BIT) & CCTRL_EVENTID));
433        /* Put cpu id */
434        ctrl = (ctrl | ((cpu << CCTRL_CPUAHBM_BIT) & CCTRL_CPUAHBM));
435        /* Enable counter */
436        ctrl = (ctrl | CCTRL_EN);
437
438        REG_WRITE(&priv->regs->cctrl[counter], ctrl);
439
440        /* DEBUG print */
441        DBG("L4STAT COUNTER[%d] enabled with event: %s, cpu: %d\n", counter, 
442                        l4stat_event_names[event],cpu);
443
444        return L4STAT_ERR_OK;
445}
446
447int l4stat_counter_disable(unsigned int counter)
448{
449        struct l4stat_priv *priv = l4statpriv;
450
451        if (priv == NULL) {
452                DBG("L4STAT Device not initialized\n");
453                return L4STAT_ERR_EINVAL;
454        }
455
456        if (counter >= priv->ncnt) {
457                DBG("L4STAT Wrong counter\n");
458                return L4STAT_ERR_EINVAL;
459        }
460
461        /* Disable counter */
462        REG_WRITE(&priv->regs->cctrl[counter], 0);
463
464        /* DEBUG print */
465        DBG("L4STAT COUNTER[%d] disabled\n", counter);
466
467        return L4STAT_ERR_OK;
468}
469
470int l4stat_counter_get(unsigned int counter, uint32_t * val)
471{
472        struct l4stat_priv *priv = l4statpriv;
473
474        if (priv == NULL) {
475                DBG("L4STAT Device not initialized\n");
476                return L4STAT_ERR_EINVAL;
477        }
478
479        if (counter >= priv->ncnt) {
480                DBG("L4STAT Wrong counter\n");
481                return L4STAT_ERR_EINVAL;
482        }
483
484        if (val == NULL) {
485                DBG("L4STAT Wrong pointer\n");
486                return L4STAT_ERR_EINVAL;
487        }
488
489        *val = REG_READ(&priv->regs->cval[counter]);
490
491        return L4STAT_ERR_OK;
492}
493
494int l4stat_counter_set(unsigned int counter, uint32_t val)
495{
496        struct l4stat_priv *priv = l4statpriv;
497
498        if (priv == NULL) {
499                DBG("L4STAT Device not initialized\n");
500                return L4STAT_ERR_EINVAL;
501        }
502
503        if (counter >= priv->ncnt) {
504                DBG("L4STAT Wrong counter\n");
505                return L4STAT_ERR_EINVAL;
506        }
507
508        REG_WRITE(&priv->regs->cval[counter],val);
509
510        return L4STAT_ERR_OK;
511}
512
513int l4stat_counter_max_get(unsigned int counter, uint32_t * val)
514{
515        struct l4stat_priv *priv = l4statpriv;
516
517        if (priv == NULL) {
518                DBG("L4STAT Device not initialized\n");
519                return L4STAT_ERR_EINVAL;
520        }
521
522        if (counter >= priv->ncnt) {
523                DBG("L4STAT Wrong counter\n");
524                return L4STAT_ERR_EINVAL;
525        }
526
527        if (val == NULL) {
528                DBG("L4STAT Wrong pointer\n");
529                return L4STAT_ERR_EINVAL;
530        }
531
532        *val = REG_READ(&priv->regs->cmax[counter]);
533
534        return L4STAT_ERR_OK;
535}
536
537int l4stat_counter_max_set(unsigned int counter, uint32_t val)
538{
539        struct l4stat_priv *priv = l4statpriv;
540
541        if (priv == NULL) {
542                DBG("L4STAT Device not initialized\n");
543                return L4STAT_ERR_EINVAL;
544        }
545
546        if (counter >= priv->ncnt) {
547                DBG("L4STAT Wrong counter\n");
548                return L4STAT_ERR_EINVAL;
549        }
550
551        REG_WRITE(&priv->regs->cmax[counter],val);
552
553        return L4STAT_ERR_OK;
554}
555
556int l4stat_tstamp_get(uint32_t * val)
557{
558        struct l4stat_priv *priv = l4statpriv;
559
560        if (priv == NULL) {
561                DBG("L4STAT Device not initialized\n");
562                return L4STAT_ERR_EINVAL;
563        }
564
565        if (val == NULL) {
566                DBG("L4STAT Wrong pointer\n");
567                return L4STAT_ERR_EINVAL;
568        }
569
570        *val = REG_READ(&priv->regs->timestamp);
571
572        return L4STAT_ERR_OK;
573}
574
575int l4stat_tstamp_set(uint32_t val)
576{
577        struct l4stat_priv *priv = l4statpriv;
578
579        if (priv == NULL) {
580                DBG("L4STAT Device not initialized\n");
581                return L4STAT_ERR_EINVAL;
582        }
583
584        REG_WRITE(&priv->regs->timestamp,val);
585
586        return L4STAT_ERR_OK;
587}
588
589int l4stat_counter_print(unsigned int counter)
590{
591#ifdef DEBUG
592        struct l4stat_priv *priv = l4statpriv;
593        unsigned int val;
594        unsigned int ctrl;
595        unsigned int event;
596
597        if (priv == NULL) {
598                DBG("L4STAT Device not initialized\n");
599                return L4STAT_ERR_EINVAL;
600        }
601
602        if (counter >= priv->ncnt) {
603                DBG("L4STAT Wrong counter\n");
604                return L4STAT_ERR_EINVAL;
605        }
606
607        /* Get counter val*/
608        val = REG_READ(&priv->regs->cval[counter]);
609
610        /* Get counter info*/
611        ctrl = REG_READ(&priv->regs->cctrl[counter]);
612        if ((ctrl & CCTRL_EN) == 0) {
613                DBG("L4STAT COUNTER[%d] disabled\n", counter);
614                return L4STAT_ERR_OK;
615        }
616
617        event = (ctrl & CCTRL_EVENTID) >> CCTRL_EVENTID_BIT;
618
619        /* DEBUG print */
620        DBG("L4STAT COUNTER[%d], Event: %s, Count: %d [0x%08x]\n", 
621                counter, l4stat_event_names[event],val,val);
622#endif /* DEBUG */
623
624        return L4STAT_ERR_OK;
625}
626
Note: See TracBrowser for help on using the repository browser.