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