video: tegra: gk20a: move pmu firmware to struct gk20a
[linux-3.10.git] / drivers / video / tegra / host / gk20a / pmu_gk20a.h
1 /*
2  * drivers/video/tegra/host/gk20a/pmu_gk20a.h
3  *
4  * GK20A PMU (aka. gPMU outside gk20a context)
5  *
6  * Copyright (c) 2011-2012, NVIDIA CORPORATION.  All rights reserved.
7  *
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms and conditions of the GNU General Public License,
10  * version 2, as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope it will be useful, but WITHOUT
13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
15  * more details.
16  *
17  * You should have received a copy of the GNU General Public License along with
18  * this program; if not, write to the Free Software Foundation, Inc.,
19  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
20  */
21 #ifndef __PMU_GK20A_H__
22 #define __PMU_GK20A_H__
23
24 /* defined by pmu hw spec */
25 #define GK20A_PMU_VA_START              ((128 * 1024) << 10)
26 #define GK20A_PMU_VA_SIZE               (512 * 1024 * 1024)
27 #define GK20A_PMU_INST_SIZE             (4 * 1024)
28 #define GK20A_PMU_UCODE_SIZE_MAX        (256 * 1024)
29
30 enum
31 {
32         GK20A_PMU_DMAIDX_UCODE          = 0,
33         GK20A_PMU_DMAIDX_VIRT           = 1,
34         GK20A_PMU_DMAIDX_PHYS_VID       = 2,
35         GK20A_PMU_DMAIDX_PHYS_SYS_COH   = 3,
36         GK20A_PMU_DMAIDX_PHYS_SYS_NCOH  = 4,
37         GK20A_PMU_DMAIDX_RSVD           = 5,
38         GK20A_PMU_DMAIDX_PELPG          = 6,
39         GK20A_PMU_DMAIDX_END            = 7
40 };
41
42 struct pmu_mem {
43         u32 dma_base;
44         u8  dma_offset;
45         u8  dma_idx;
46 };
47
48 /* Make sure size of this structure is a multiple of 4 bytes */
49 struct pmu_cmdline_args {
50         u32 cpu_freq_HZ;                /* Frequency of the clock driving the PMU */
51         u32 falc_trace_size;            /* falctrace buffer size (bytes) */
52         u32 falc_trace_dma_base;        /* 256-byte block address */
53         u32 falc_trace_dma_idx;         /* dmaIdx for DMA operations */
54         struct pmu_mem gc6_ctx;         /* dmem offset of gc6 context */
55 };
56
57 #define GK20A_PMU_DMEM_BLKSIZE2         8
58
59 #define GK20A_PMU_UCODE_NB_MAX_OVERLAY      32
60 #define GK20A_PMU_UCODE_NB_MAX_DATE_LENGTH  64
61
62 struct pmu_ucode_desc {
63         u32 descriptor_size;
64         u32 image_size;
65         u32 tools_version;
66         u32 app_version;
67         char date[GK20A_PMU_UCODE_NB_MAX_DATE_LENGTH];
68         u32 bootloader_start_offset;
69         u32 bootloader_size;
70         u32 bootloader_imem_offset;
71         u32 bootloader_entry_point;
72         u32 app_start_offset;
73         u32 app_size;
74         u32 app_imem_offset;
75         u32 app_imem_entry;
76         u32 app_dmem_offset;
77         u32 app_resident_code_offset;  /* Offset from appStartOffset */
78         u32 app_resident_code_size;    /* Exact size of the resident code ( potentially contains CRC inside at the end ) */
79         u32 app_resident_data_offset;  /* Offset from appStartOffset */
80         u32 app_resident_data_size;    /* Exact size of the resident code ( potentially contains CRC inside at the end ) */
81         u32 nb_overlays;
82         struct {u32 start; u32 size;} load_ovl[GK20A_PMU_UCODE_NB_MAX_OVERLAY];
83         u32 compressed;
84 };
85
86 #define PMU_UNIT_REWIND         (0x00)
87 #define PMU_UNIT_I2C            (0x01)
88 #define PMU_UNIT_SEQ            (0x02)
89 #define PMU_UNIT_PG             (0x03)
90 #define PMU_UNIT_AVAILABLE1     (0x04)
91 #define PMU_UNIT_AVAILABLE2     (0x05)
92 #define PMU_UNIT_MEM            (0x06)
93 #define PMU_UNIT_INIT           (0x07)
94 #define PMU_UNIT_FBBA           (0x08)
95 #define PMU_UNIT_DIDLE          (0x09)
96 #define PMU_UNIT_AVAILABLE3     (0x0A)
97 #define PMU_UNIT_AVAILABLE4     (0x0B)
98 #define PMU_UNIT_HDCP_MAIN      (0x0C)
99 #define PMU_UNIT_HDCP_V         (0x0D)
100 #define PMU_UNIT_HDCP_SRM       (0x0E)
101 #define PMU_UNIT_NVDPS          (0x0F)
102 #define PMU_UNIT_DEINIT         (0x10)
103 #define PMU_UNIT_AVAILABLE5     (0x11)
104 #define PMU_UNIT_PERFMON        (0x12)
105 #define PMU_UNIT_FAN            (0x13)
106 #define PMU_UNIT_PBI            (0x14)
107 #define PMU_UNIT_ISOBLIT        (0x15)
108 #define PMU_UNIT_DETACH         (0x16)
109 #define PMU_UNIT_DISP           (0x17)
110 #define PMU_UNIT_HDCP           (0x18)
111 #define PMU_UNIT_REGCACHE       (0x19)
112 #define PMU_UNIT_SYSMON         (0x1A)
113 #define PMU_UNIT_THERM          (0x1B)
114 #define PMU_UNIT_PMGR           (0x1C)
115 #define PMU_UNIT_PERF           (0x1D)
116 #define PMU_UNIT_PCM            (0x1E)
117 #define PMU_UNIT_RC             (0x1F)
118 #define PMU_UNIT_NULL           (0x20)
119 #define PMU_UNIT_LOGGER         (0x21)
120 #define PMU_UNIT_SMBPBI         (0x22)
121 #define PMU_UNIT_END            (0x23)
122
123 #define PMU_UNIT_TEST_START     (0xFE)
124 #define PMU_UNIT_END_SIM        (0xFF)
125 #define PMU_UNIT_TEST_END       (0xFF)
126
127 #define PMU_UNIT_ID_IS_VALID(id)                \
128                 (((id) < PMU_UNIT_END) || ((id) >= PMU_UNIT_TEST_START))
129
130 #define PMU_DMEM_ALLOC_ALIGNMENT        (32)
131 #define PMU_DMEM_ALIGNMENT              (4)
132
133 #define PMU_CMD_FLAGS_PMU_MASK          (0xF0)
134
135 #define PMU_CMD_FLAGS_STATUS            BIT(0)
136 #define PMU_CMD_FLAGS_INTR              BIT(1)
137 #define PMU_CMD_FLAGS_EVENT             BIT(2)
138 #define PMU_CMD_FLAGS_WATERMARK         BIT(3)
139
140 struct pmu_hdr {
141         u8 unit_id;
142         u8 size;
143         u8 ctrl_flags;
144         u8 seq_id;
145 };
146 #define PMU_MSG_HDR_SIZE        sizeof(struct pmu_hdr)
147 #define PMU_CMD_HDR_SIZE        sizeof(struct pmu_hdr)
148
149 #define PMU_QUEUE_COUNT         5
150
151 struct pmu_allocation {
152         u8 pad[2];
153         u16 size;
154         u32 offset;
155 };
156
157 enum {
158         PMU_INIT_MSG_TYPE_PMU_INIT = 0,
159 };
160
161 struct pmu_init_msg_pmu {
162         u8 msg_type;
163         u8 pad;
164
165         struct {
166                 u16 size;
167                 u16 offset;
168                 u8  index;
169                 u8  pad;
170         } queue_info [PMU_QUEUE_COUNT];
171
172         u16 sw_managed_area_offset;
173         u16 sw_managed_area_size;
174 };
175
176 struct pmu_init_msg {
177         union {
178                 u8 msg_type;
179                 struct pmu_init_msg_pmu pmu_init;
180         };
181 };
182
183 enum {
184         PMU_PG_ELPG_MSG_INIT_ACK,
185         PMU_PG_ELPG_MSG_DISALLOW_ACK,
186         PMU_PG_ELPG_MSG_ALLOW_ACK,
187         PMU_PG_ELPG_MSG_FREEZE_ACK,
188         PMU_PG_ELPG_MSG_FREEZE_ABORT,
189         PMU_PG_ELPG_MSG_UNFREEZE_ACK,
190 };
191
192 struct pmu_pg_msg_elpg_msg {
193         u8 msg_type;
194         u8 engine_id;
195         u16 msg;
196 };
197
198 enum {
199         PMU_PG_STAT_MSG_RESP_DMEM_OFFSET = 0,
200 };
201
202 struct pmu_pg_msg_stat {
203         u8 msg_type;
204         u8 engine_id;
205         u16 sub_msg_id;
206         u32 data;
207 };
208
209 enum {
210         PMU_PG_MSG_ENG_BUF_LOADED,
211         PMU_PG_MSG_ENG_BUF_UNLOADED,
212         PMU_PG_MSG_ENG_BUF_FAILED,
213 };
214
215 struct pmu_pg_msg_eng_buf_stat {
216         u8 msg_type;
217         u8 engine_id;
218         u8 buf_idx;
219         u8 status;
220 };
221
222 struct pmu_pg_msg {
223         union {
224                 u8 msg_type;
225                 struct pmu_pg_msg_elpg_msg elpg_msg;
226                 struct pmu_pg_msg_stat stat;
227                 struct pmu_pg_msg_eng_buf_stat eng_buf_stat;
228                 /* TBD: other pg messages */
229         };
230 };
231
232 enum {
233         PMU_RC_MSG_TYPE_UNHANDLED_CMD = 0,
234 };
235
236 struct pmu_rc_msg_unhandled_cmd {
237         u8 msg_type;
238         u8 unit_id;
239 };
240
241 struct pmu_rc_msg {
242         u8 msg_type;
243         struct pmu_rc_msg_unhandled_cmd unhandled_cmd;
244 };
245
246 enum {
247         PMU_PG_CMD_ID_ELPG_CMD = 0,
248         PMU_PG_CMD_ID_ENG_BUF_LOAD,
249         PMU_PG_CMD_ID_ENG_BUF_UNLOAD,
250         PMU_PG_CMD_ID_PG_STAT,
251         PMU_PG_CMD_ID_PG_LOG_INIT,
252         PMU_PG_CMD_ID_PG_LOG_FLUSH,
253         PMU_PG_CMD_ID_PG_PARAM,
254         PMU_PG_CMD_ID_ELPG_INIT,
255         PMU_PG_CMD_ID_ELPG_POLL_CTXSAVE,
256         PMU_PG_CMD_ID_ELPG_ABORT_POLL,
257         PMU_PG_CMD_ID_ELPG_PWR_UP,
258         PMU_PG_CMD_ID_ELPG_DISALLOW,
259         PMU_PG_CMD_ID_ELPG_ALLOW,
260         PMU_PG_CMD_ID_PWR_RAIL_GATE_DISABLE = 0x20,
261         PMU_PG_CMD_ID_PWR_RAIL_GATE_ENABLE,
262         PMU_PG_CMD_ID_PWR_RAIL_SMU_MSG_DISABLE
263 };
264
265 enum {
266         PMU_PG_ELPG_CMD_INIT,
267         PMU_PG_ELPG_CMD_DISALLOW,
268         PMU_PG_ELPG_CMD_ALLOW,
269         PMU_PG_ELPG_CMD_FREEZE,
270         PMU_PG_ELPG_CMD_UNFREEZE,
271 };
272
273 struct pmu_pg_cmd_elpg_cmd {
274         u8 cmd_type;
275         u8 engine_id;
276         u16 cmd;
277 };
278
279 struct pmu_pg_cmd_eng_buf_load {
280         u8 cmd_type;
281         u8 engine_id;
282         u8 buf_idx;
283         u8 pad;
284         u16 buf_size;
285         u32 dma_base;
286         u8 dma_offset;
287         u8 dma_idx;
288 };
289
290 enum {
291         PMU_PG_STAT_CMD_ALLOC_DMEM = 0,
292 };
293
294 struct pmu_pg_cmd_stat {
295         u8 cmd_type;
296         u8 engine_id;
297         u16 sub_cmd_id;
298         u32 data;
299 };
300
301 struct pmu_pg_cmd {
302         union {
303                 u8 cmd_type;
304                 struct pmu_pg_cmd_elpg_cmd elpg_cmd;
305                 struct pmu_pg_cmd_eng_buf_load eng_buf_load;
306                 struct pmu_pg_cmd_stat stat;
307                 /* TBD: other pg commands */
308         };
309 };
310
311 /* PERFMON */
312 #define PMU_DOMAIN_GROUP_PSTATE         0
313 #define PMU_DOMAIN_GROUP_GPC2CLK        1
314 #define PMU_DOMAIN_GROUP_NUM            2
315
316 /* TBD: smart strategy */
317 #define PMU_PERFMON_PCT_TO_INC          58
318 #define PMU_PERFMON_PCT_TO_DEC          23
319
320 struct pmu_perfmon_counter {
321         u8 index;
322         u8 flags;
323         u8 group_id;
324         u8 valid;
325         u16 upper_threshold; /* units of 0.01% */
326         u16 lower_threshold; /* units of 0.01% */
327 };
328
329 #define PMU_PERFMON_FLAG_ENABLE_INCREASE        (0x00000001)
330 #define PMU_PERFMON_FLAG_ENABLE_DECREASE        (0x00000002)
331 #define PMU_PERFMON_FLAG_CLEAR_PREV             (0x00000004)
332
333 /* PERFMON CMD */
334 enum {
335         PMU_PERFMON_CMD_ID_START = 0,
336         PMU_PERFMON_CMD_ID_STOP  = 1,
337         PMU_PERFMON_CMD_ID_INIT  = 2
338 };
339
340 struct pmu_perfmon_cmd_start {
341         u8 cmd_type;
342         u8 group_id;
343         u8 state_id;
344         u8 flags;
345         struct pmu_allocation counter_alloc;
346 };
347
348 struct pmu_perfmon_cmd_stop {
349         u8 cmd_type;
350 };
351
352 struct pmu_perfmon_cmd_init {
353         u8 cmd_type;
354         u8 to_decrease_count;
355         u8 base_counter_id;
356         u32 sample_period_us;
357         struct pmu_allocation counter_alloc;
358         u8 num_counters;
359         u8 samples_in_moving_avg;
360         u16 sample_buffer;
361 };
362
363 struct pmu_perfmon_cmd {
364         union {
365                 u8 cmd_type;
366                 struct pmu_perfmon_cmd_start start;
367                 struct pmu_perfmon_cmd_stop stop;
368                 struct pmu_perfmon_cmd_init init;
369         };
370 };
371
372 /* PERFMON MSG */
373 enum {
374         PMU_PERFMON_MSG_ID_INCREASE_EVENT = 0,
375         PMU_PERFMON_MSG_ID_DECREASE_EVENT = 1,
376         PMU_PERFMON_MSG_ID_INIT_EVENT     = 2,
377         PMU_PERFMON_MSG_ID_ACK            = 3
378 };
379
380 struct pmu_perfmon_msg_generic {
381         u8 msg_type;
382         u8 state_id;
383         u8 group_id;
384         u8 data;
385 };
386
387 struct pmu_perfmon_msg {
388         union {
389                 u8 msg_type;
390                 struct pmu_perfmon_msg_generic gen;
391         };
392 };
393
394
395 struct pmu_cmd {
396         struct pmu_hdr hdr;
397         union {
398                 struct pmu_perfmon_cmd perfmon;
399                 struct pmu_pg_cmd pg;
400         } cmd;
401 };
402
403 struct pmu_msg {
404         struct pmu_hdr hdr;
405         union {
406                 struct pmu_init_msg init;
407                 struct pmu_perfmon_msg perfmon;
408                 struct pmu_pg_msg pg;
409                 struct pmu_rc_msg rc;
410         } msg;
411 };
412
413 #define PMU_SHA1_GID_SIGNATURE          0xA7C66AD2
414 #define PMU_SHA1_GID_SIGNATURE_SIZE     4
415
416 #define PMU_SHA1_GID_SIZE       16
417
418 struct pmu_sha1_gid {
419         bool valid;
420         u8 gid[PMU_SHA1_GID_SIZE];
421 };
422
423 struct pmu_sha1_gid_data {
424         u8 signature[PMU_SHA1_GID_SIGNATURE_SIZE];
425         u8 gid[PMU_SHA1_GID_SIZE];
426 };
427
428 #define PMU_COMMAND_QUEUE_HPQ           0       /* write by sw, read by pmu, protected by sw mutex lock */
429 #define PMU_COMMAND_QUEUE_LPQ           1       /* write by sw, read by pmu, protected by sw mutex lock */
430 #define PMU_COMMAND_QUEUE_BIOS          2       /* read/write by sw/hw, protected by hw pmu mutex, id = 2 */
431 #define PMU_COMMAND_QUEUE_SMI           3       /* read/write by sw/hw, protected by hw pmu mutex, id = 3 */
432 #define PMU_MESSAGE_QUEUE               4       /* write by pmu, read by sw, accessed by interrupt handler, no lock */
433 #define PMU_QUEUE_COUNT                 5
434
435 enum {
436         PMU_MUTEX_ID_RSVD1 = 0  ,
437         PMU_MUTEX_ID_GPUSER     ,
438         PMU_MUTEX_ID_QUEUE_BIOS ,
439         PMU_MUTEX_ID_QUEUE_SMI  ,
440         PMU_MUTEX_ID_GPMUTEX    ,
441         PMU_MUTEX_ID_I2C        ,
442         PMU_MUTEX_ID_RMLOCK     ,
443         PMU_MUTEX_ID_MSGBOX     ,
444         PMU_MUTEX_ID_FIFO       ,
445         PMU_MUTEX_ID_PG         ,
446         PMU_MUTEX_ID_GR         ,
447         PMU_MUTEX_ID_CLK        ,
448         PMU_MUTEX_ID_RSVD6      ,
449         PMU_MUTEX_ID_RSVD7      ,
450         PMU_MUTEX_ID_RSVD8      ,
451         PMU_MUTEX_ID_RSVD9      ,
452         PMU_MUTEX_ID_INVALID
453 };
454
455 #define PMU_IS_COMMAND_QUEUE(id)        \
456                 ((id)  < PMU_MESSAGE_QUEUE)
457
458 #define PMU_IS_SW_COMMAND_QUEUE(id)     \
459                 (((id) == PMU_COMMAND_QUEUE_HPQ) || \
460                  ((id) == PMU_COMMAND_QUEUE_LPQ))
461
462 #define  PMU_IS_MESSAGE_QUEUE(id)       \
463                 ((id) == PMU_MESSAGE_QUEUE)
464
465 enum
466 {
467         OFLAG_READ = 0,
468         OFLAG_WRITE
469 };
470
471 #define QUEUE_SET               (true)
472 #define QUEUE_GET               (false)
473
474 #define QUEUE_ALIGNMENT         (4)
475
476 #define PMU_PGENG_GR_BUFFER_IDX_INIT    (0)
477 #define PMU_PGENG_GR_BUFFER_IDX_ZBC     (1)
478 #define PMU_PGENG_GR_BUFFER_IDX_FECS    (2)
479
480 enum
481 {
482     PMU_DMAIDX_UCODE         = 0,
483     PMU_DMAIDX_VIRT          = 1,
484     PMU_DMAIDX_PHYS_VID      = 2,
485     PMU_DMAIDX_PHYS_SYS_COH  = 3,
486     PMU_DMAIDX_PHYS_SYS_NCOH = 4,
487     PMU_DMAIDX_RSVD          = 5,
488     PMU_DMAIDX_PELPG         = 6,
489     PMU_DMAIDX_END           = 7
490 };
491
492 struct pmu_gk20a;
493 struct pmu_queue;
494
495 struct pmu_queue {
496
497         /* used by hw, for BIOS/SMI queue */
498         u32 mutex_id;
499         u32 mutex_lock;
500         /* used by sw, for LPQ/HPQ queue */
501         struct mutex mutex;
502
503         /* current write position */
504         u32 position;
505         /* physical dmem offset where this queue begins */
506         u32 offset;
507         /* logical queue identifier */
508         u32 id;
509         /* physical queue index */
510         u32 index;
511         /* in bytes */
512         u32 size;
513
514         /* open-flag */
515         u32 oflag;
516         bool opened; /* opened implies locked */
517         bool locked; /* check free space after setting locked but before setting opened */
518 };
519
520
521 #define PMU_MUTEX_ID_IS_VALID(id)       \
522                 ((id) < PMU_MUTEX_ID_INVALID)
523
524 #define PMU_INVALID_MUTEX_OWNER_ID      (0)
525
526 struct pmu_mutex {
527         u32 id;
528         u32 index;
529         u32 ref_cnt;
530 };
531
532 #define PMU_MAX_NUM_SEQUENCES           (256)
533 #define PMU_SEQ_BIT_SHIFT               (5)
534 #define PMU_SEQ_TBL_SIZE        \
535                 (PMU_MAX_NUM_SEQUENCES >> PMU_SEQ_BIT_SHIFT)
536
537 #define PMU_INVALID_SEQ_DESC            (~0)
538
539 enum
540 {
541         PMU_SEQ_STATE_FREE = 0,
542         PMU_SEQ_STATE_PENDING,
543         PMU_SEQ_STATE_USED,
544         PMU_SEQ_STATE_CANCELLED
545 };
546
547 struct pmu_payload {
548         struct {
549                 void *buf;
550                 u32 offset;
551                 u32 size;
552         } in, out;
553 };
554
555 typedef void (*pmu_callback)(struct gk20a *, struct pmu_msg *, void *, u32, u32);
556
557 struct pmu_sequence {
558         u8 id;
559         u32 state;
560         u32 desc;
561         struct pmu_msg *msg;
562         struct pmu_allocation in;
563         struct pmu_allocation out;
564         u8 *out_payload;
565         pmu_callback callback;
566         void* cb_params;
567 };
568
569 struct pmu_pg_stats {
570         u64 pg_entry_start_timestamp;
571         u64 pg_ingating_start_timestamp;
572         u64 pg_exit_start_timestamp;
573         u64 pg_ungating_start_timestamp;
574         u32 pg_avg_entry_time_us;
575         u32 pg_ingating_cnt;
576         u32 pg_ingating_time_us;
577         u32 pg_avg_exit_time_us;
578         u32 pg_ungating_count;
579         u32 pg_ungating_time_us;
580         u32 pg_gating_cnt;
581         u32 pg_gating_deny_cnt;
582 };
583
584 #if defined (CONFIG_TEGRA_SIMULATION_PLATFORM) /* SIM */
585 #define PMU_PG_IDLE_THRESHOLD                   1000
586 #define PMU_PG_POST_POWERUP_IDLE_THRESHOLD      4000000
587 #else /* TBD: QT or else ? */
588 #define PMU_PG_IDLE_THRESHOLD                   15000
589 #define PMU_PG_POST_POWERUP_IDLE_THRESHOLD      1000000
590 #endif
591
592 /* state transition :
593     OFF => [OFF_ON_PENDING optional] => ON_PENDING => ON => OFF
594     ON => OFF is always synchronized */
595 #define PMU_ELPG_STAT_OFF               0   /* elpg is off */
596 #define PMU_ELPG_STAT_ON                1   /* elpg is on */
597 #define PMU_ELPG_STAT_ON_PENDING        2   /* elpg is off, ALLOW cmd has been sent, wait for ack */
598 #define PMU_ELPG_STAT_OFF_PENDING       3   /* elpg is on, DISALLOW cmd has been sent, wait for ack */
599 #define PMU_ELPG_STAT_OFF_ON_PENDING    4   /* elpg is off, caller has requested on, but ALLOW
600                                                cmd hasn't been sent due to ENABLE_ALLOW delay */
601
602 /* Falcon Register index */
603 #define PMU_FALCON_REG_R0               (0)
604 #define PMU_FALCON_REG_R1               (1)
605 #define PMU_FALCON_REG_R2               (2)
606 #define PMU_FALCON_REG_R3               (3)
607 #define PMU_FALCON_REG_R4               (4)
608 #define PMU_FALCON_REG_R5               (5)
609 #define PMU_FALCON_REG_R6               (6)
610 #define PMU_FALCON_REG_R7               (7)
611 #define PMU_FALCON_REG_R8               (8)
612 #define PMU_FALCON_REG_R9               (9)
613 #define PMU_FALCON_REG_R10              (10)
614 #define PMU_FALCON_REG_R11              (11)
615 #define PMU_FALCON_REG_R12              (12)
616 #define PMU_FALCON_REG_R13              (13)
617 #define PMU_FALCON_REG_R14              (14)
618 #define PMU_FALCON_REG_R15              (15)
619 #define PMU_FALCON_REG_IV0              (16)
620 #define PMU_FALCON_REG_IV1              (17)
621 #define PMU_FALCON_REG_UNDEFINED        (18)
622 #define PMU_FALCON_REG_EV               (19)
623 #define PMU_FALCON_REG_SP               (20)
624 #define PMU_FALCON_REG_PC               (21)
625 #define PMU_FALCON_REG_IMB              (22)
626 #define PMU_FALCON_REG_DMB              (23)
627 #define PMU_FALCON_REG_CSW              (24)
628 #define PMU_FALCON_REG_CCR              (25)
629 #define PMU_FALCON_REG_SEC              (26)
630 #define PMU_FALCON_REG_CTX              (27)
631 #define PMU_FALCON_REG_EXCI             (28)
632 #define PMU_FALCON_REG_RSVD0            (29)
633 #define PMU_FALCON_REG_RSVD1            (30)
634 #define PMU_FALCON_REG_RSVD2            (31)
635 #define PMU_FALCON_REG_SIZE             (32)
636
637 struct pmu_gk20a {
638
639         struct gk20a *g;
640
641         struct pmu_ucode_desc *desc;
642         struct pmu_mem_desc ucode;
643
644         struct pmu_mem_desc pg_buf;
645         /* TBD: remove this if ZBC seq is fixed */
646         struct pmu_mem_desc seq_buf;
647         bool buf_loaded;
648
649         struct pmu_cmdline_args args;
650         struct pmu_sha1_gid gid_info;
651
652         struct pmu_queue queue[PMU_QUEUE_COUNT];
653
654         struct pmu_sequence *seq;
655         unsigned long pmu_seq_tbl[PMU_SEQ_TBL_SIZE];
656         u32 next_seq_desc;
657
658         struct pmu_mutex *mutex;
659         u32 mutex_cnt;
660
661         struct nvhost_allocator dmem;
662
663         u32 *ucode_image;
664         bool pmu_ready;
665
666         u32 stat_dmem_offset;
667
668         bool elpg_ready;
669         u32 elpg_stat;
670         wait_queue_head_t pg_wq;
671
672 #define PMU_ELPG_ENABLE_ALLOW_DELAY_MSEC        1 /* msec */
673         struct delayed_work elpg_enable; /* deferred elpg enable */
674         bool elpg_enable_allow; /* true after init, false after disable, true after delay */
675         struct mutex elpg_mutex; /* protect elpg enable/disable */
676         int elpg_refcnt; /* disable -1, enable +1, <=0 elpg disabled, > 0 elpg enabled */
677
678         struct pmu_perfmon_counter perfmon_counter;
679         u32 perfmon_state_id[PMU_DOMAIN_GROUP_NUM];
680
681         bool initialized;
682
683         void (*remove_support)(struct pmu_gk20a *pmu);
684         bool sw_ready;
685 };
686
687 int gk20a_init_pmu_support(struct gk20a *g);
688
689 void gk20a_pmu_isr(struct gk20a *g);
690
691 /* send a cmd to pmu */
692 int gk20a_pmu_cmd_post(struct gk20a *g, struct pmu_cmd *cmd, struct pmu_msg *msg,
693                 struct pmu_payload *payload, u32 queue_id,
694                 pmu_callback callback, void* cb_param,
695                 u32 *seq_desc, u32 timeout);
696
697 int gk20a_pmu_enable_elpg(struct gk20a *g);
698 int gk20a_pmu_disable_elpg(struct gk20a *g);
699
700 int gk20a_pmu_perfmon_enable(struct gk20a *g, bool enable);
701
702 int pmu_mutex_acquire(struct pmu_gk20a *pmu, u32 id, u32 *token);
703 int pmu_mutex_release(struct pmu_gk20a *pmu, u32 id, u32 *token);
704 int gk20a_pmu_destroy(struct gk20a *g);
705
706 #endif /*__PMU_GK20A_H__*/