1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (c) 2014 MediaTek Inc.
4 * Author: Flora Fu, MediaTek
5 */
6 #include <linux/clk.h>
7 #include <linux/interrupt.h>
8 #include <linux/io.h>
9 #include <linux/kernel.h>
10 #include <linux/module.h>
11 #include <linux/of.h>
12 #include <linux/of_platform.h>
13 #include <linux/platform_device.h>
14 #include <linux/regmap.h>
15 #include <linux/reset.h>
16
17 #define PWRAP_POLL_DELAY_US 10
18 #define PWRAP_POLL_TIMEOUT_US 10000
19
20 #define PWRAP_MT8135_BRIDGE_IORD_ARB_EN 0x4
21 #define PWRAP_MT8135_BRIDGE_WACS3_EN 0x10
22 #define PWRAP_MT8135_BRIDGE_INIT_DONE3 0x14
23 #define PWRAP_MT8135_BRIDGE_WACS4_EN 0x24
24 #define PWRAP_MT8135_BRIDGE_INIT_DONE4 0x28
25 #define PWRAP_MT8135_BRIDGE_INT_EN 0x38
26 #define PWRAP_MT8135_BRIDGE_TIMER_EN 0x48
27 #define PWRAP_MT8135_BRIDGE_WDT_UNIT 0x50
28 #define PWRAP_MT8135_BRIDGE_WDT_SRC_EN 0x54
29
30 /* macro for wrapper status */
31 #define PWRAP_GET_WACS_RDATA(x) (((x) >> 0) & 0x0000ffff)
32 #define PWRAP_GET_WACS_ARB_FSM(x) (((x) >> 1) & 0x00000007)
33 #define PWRAP_GET_WACS_FSM(x) (((x) >> 16) & 0x00000007)
34 #define PWRAP_GET_WACS_REQ(x) (((x) >> 19) & 0x00000001)
35 #define PWRAP_STATE_SYNC_IDLE0 BIT(20)
36 #define PWRAP_STATE_INIT_DONE0 BIT(21)
37 #define PWRAP_STATE_INIT_DONE0_MT8186 BIT(22)
38 #define PWRAP_STATE_INIT_DONE1 BIT(15)
39
40 /* macro for WACS FSM */
41 #define PWRAP_WACS_FSM_IDLE 0x00
42 #define PWRAP_WACS_FSM_REQ 0x02
43 #define PWRAP_WACS_FSM_WFDLE 0x04
44 #define PWRAP_WACS_FSM_WFVLDCLR 0x06
45 #define PWRAP_WACS_INIT_DONE 0x01
46 #define PWRAP_WACS_WACS_SYNC_IDLE 0x01
47 #define PWRAP_WACS_SYNC_BUSY 0x00
48
49 /* macro for device wrapper default value */
50 #define PWRAP_DEW_READ_TEST_VAL 0x5aa5
51 #define PWRAP_DEW_COMP_READ_TEST_VAL 0xa55a
52 #define PWRAP_DEW_WRITE_TEST_VAL 0xa55a
53
54 /* macro for manual command */
55 #define PWRAP_MAN_CMD_SPI_WRITE_NEW (1 << 14)
56 #define PWRAP_MAN_CMD_SPI_WRITE (1 << 13)
57 #define PWRAP_MAN_CMD_OP_CSH (0x0 << 8)
58 #define PWRAP_MAN_CMD_OP_CSL (0x1 << 8)
59 #define PWRAP_MAN_CMD_OP_CK (0x2 << 8)
60 #define PWRAP_MAN_CMD_OP_OUTS (0x8 << 8)
61 #define PWRAP_MAN_CMD_OP_OUTD (0x9 << 8)
62 #define PWRAP_MAN_CMD_OP_OUTQ (0xa << 8)
63
64 /* macro for Watch Dog Timer Source */
65 #define PWRAP_WDT_SRC_EN_STAUPD_TRIG (1 << 25)
66 #define PWRAP_WDT_SRC_EN_HARB_STAUPD_DLE (1 << 20)
67 #define PWRAP_WDT_SRC_EN_HARB_STAUPD_ALE (1 << 6)
68 #define PWRAP_WDT_SRC_MASK_ALL 0xffffffff
69 #define PWRAP_WDT_SRC_MASK_NO_STAUPD ~(PWRAP_WDT_SRC_EN_STAUPD_TRIG | \
70 PWRAP_WDT_SRC_EN_HARB_STAUPD_DLE | \
71 PWRAP_WDT_SRC_EN_HARB_STAUPD_ALE)
72
73 /* Group of bits used for shown slave capability */
74 #define PWRAP_SLV_CAP_SPI BIT(0)
75 #define PWRAP_SLV_CAP_DUALIO BIT(1)
76 #define PWRAP_SLV_CAP_SECURITY BIT(2)
77 #define HAS_CAP(_c, _x) (((_c) & (_x)) == (_x))
78
79 /* Group of bits used for shown pwrap capability */
80 #define PWRAP_CAP_BRIDGE BIT(0)
81 #define PWRAP_CAP_RESET BIT(1)
82 #define PWRAP_CAP_DCM BIT(2)
83 #define PWRAP_CAP_INT1_EN BIT(3)
84 #define PWRAP_CAP_WDT_SRC1 BIT(4)
85 #define PWRAP_CAP_ARB BIT(5)
86 #define PWRAP_CAP_ARB_MT8186 BIT(8)
87
88 /* defines for slave device wrapper registers */
89 enum dew_regs {
90 PWRAP_DEW_BASE,
91 PWRAP_DEW_DIO_EN,
92 PWRAP_DEW_READ_TEST,
93 PWRAP_DEW_WRITE_TEST,
94 PWRAP_DEW_CRC_EN,
95 PWRAP_DEW_CRC_VAL,
96 PWRAP_DEW_MON_GRP_SEL,
97 PWRAP_DEW_CIPHER_KEY_SEL,
98 PWRAP_DEW_CIPHER_IV_SEL,
99 PWRAP_DEW_CIPHER_RDY,
100 PWRAP_DEW_CIPHER_MODE,
101 PWRAP_DEW_CIPHER_SWRST,
102
103 /* MT6323 only regs */
104 PWRAP_DEW_CIPHER_EN,
105 PWRAP_DEW_RDDMY_NO,
106
107 /* MT6358 only regs */
108 PWRAP_SMT_CON1,
109 PWRAP_DRV_CON1,
110 PWRAP_FILTER_CON0,
111 PWRAP_GPIO_PULLEN0_CLR,
112 PWRAP_RG_SPI_CON0,
113 PWRAP_RG_SPI_RECORD0,
114 PWRAP_RG_SPI_CON2,
115 PWRAP_RG_SPI_CON3,
116 PWRAP_RG_SPI_CON4,
117 PWRAP_RG_SPI_CON5,
118 PWRAP_RG_SPI_CON6,
119 PWRAP_RG_SPI_CON7,
120 PWRAP_RG_SPI_CON8,
121 PWRAP_RG_SPI_CON13,
122 PWRAP_SPISLV_KEY,
123
124 /* MT6359 only regs */
125 PWRAP_DEW_CRC_SWRST,
126 PWRAP_DEW_RG_EN_RECORD,
127 PWRAP_DEW_RECORD_CMD0,
128 PWRAP_DEW_RECORD_CMD1,
129 PWRAP_DEW_RECORD_CMD2,
130 PWRAP_DEW_RECORD_CMD3,
131 PWRAP_DEW_RECORD_CMD4,
132 PWRAP_DEW_RECORD_CMD5,
133 PWRAP_DEW_RECORD_WDATA0,
134 PWRAP_DEW_RECORD_WDATA1,
135 PWRAP_DEW_RECORD_WDATA2,
136 PWRAP_DEW_RECORD_WDATA3,
137 PWRAP_DEW_RECORD_WDATA4,
138 PWRAP_DEW_RECORD_WDATA5,
139 PWRAP_DEW_RG_ADDR_TARGET,
140 PWRAP_DEW_RG_ADDR_MASK,
141 PWRAP_DEW_RG_WDATA_TARGET,
142 PWRAP_DEW_RG_WDATA_MASK,
143 PWRAP_DEW_RG_SPI_RECORD_CLR,
144 PWRAP_DEW_RG_CMD_ALERT_CLR,
145
146 /* MT6397 only regs */
147 PWRAP_DEW_EVENT_OUT_EN,
148 PWRAP_DEW_EVENT_SRC_EN,
149 PWRAP_DEW_EVENT_SRC,
150 PWRAP_DEW_EVENT_FLAG,
151 PWRAP_DEW_MON_FLAG_SEL,
152 PWRAP_DEW_EVENT_TEST,
153 PWRAP_DEW_CIPHER_LOAD,
154 PWRAP_DEW_CIPHER_START,
155 };
156
157 static const u32 mt6323_regs[] = {
158 [PWRAP_DEW_BASE] = 0x0000,
159 [PWRAP_DEW_DIO_EN] = 0x018a,
160 [PWRAP_DEW_READ_TEST] = 0x018c,
161 [PWRAP_DEW_WRITE_TEST] = 0x018e,
162 [PWRAP_DEW_CRC_EN] = 0x0192,
163 [PWRAP_DEW_CRC_VAL] = 0x0194,
164 [PWRAP_DEW_MON_GRP_SEL] = 0x0196,
165 [PWRAP_DEW_CIPHER_KEY_SEL] = 0x0198,
166 [PWRAP_DEW_CIPHER_IV_SEL] = 0x019a,
167 [PWRAP_DEW_CIPHER_EN] = 0x019c,
168 [PWRAP_DEW_CIPHER_RDY] = 0x019e,
169 [PWRAP_DEW_CIPHER_MODE] = 0x01a0,
170 [PWRAP_DEW_CIPHER_SWRST] = 0x01a2,
171 [PWRAP_DEW_RDDMY_NO] = 0x01a4,
172 };
173
174 static const u32 mt6331_regs[] = {
175 [PWRAP_DEW_DIO_EN] = 0x018c,
176 [PWRAP_DEW_READ_TEST] = 0x018e,
177 [PWRAP_DEW_WRITE_TEST] = 0x0190,
178 [PWRAP_DEW_CRC_SWRST] = 0x0192,
179 [PWRAP_DEW_CRC_EN] = 0x0194,
180 [PWRAP_DEW_CRC_VAL] = 0x0196,
181 [PWRAP_DEW_MON_GRP_SEL] = 0x0198,
182 [PWRAP_DEW_CIPHER_KEY_SEL] = 0x019a,
183 [PWRAP_DEW_CIPHER_IV_SEL] = 0x019c,
184 [PWRAP_DEW_CIPHER_EN] = 0x019e,
185 [PWRAP_DEW_CIPHER_RDY] = 0x01a0,
186 [PWRAP_DEW_CIPHER_MODE] = 0x01a2,
187 [PWRAP_DEW_CIPHER_SWRST] = 0x01a4,
188 [PWRAP_DEW_RDDMY_NO] = 0x01a6,
189 };
190
191 static const u32 mt6332_regs[] = {
192 [PWRAP_DEW_DIO_EN] = 0x80f6,
193 [PWRAP_DEW_READ_TEST] = 0x80f8,
194 [PWRAP_DEW_WRITE_TEST] = 0x80fa,
195 [PWRAP_DEW_CRC_SWRST] = 0x80fc,
196 [PWRAP_DEW_CRC_EN] = 0x80fe,
197 [PWRAP_DEW_CRC_VAL] = 0x8100,
198 [PWRAP_DEW_MON_GRP_SEL] = 0x8102,
199 [PWRAP_DEW_CIPHER_KEY_SEL] = 0x8104,
200 [PWRAP_DEW_CIPHER_IV_SEL] = 0x8106,
201 [PWRAP_DEW_CIPHER_EN] = 0x8108,
202 [PWRAP_DEW_CIPHER_RDY] = 0x810a,
203 [PWRAP_DEW_CIPHER_MODE] = 0x810c,
204 [PWRAP_DEW_CIPHER_SWRST] = 0x810e,
205 [PWRAP_DEW_RDDMY_NO] = 0x8110,
206 };
207
208 static const u32 mt6351_regs[] = {
209 [PWRAP_DEW_DIO_EN] = 0x02F2,
210 [PWRAP_DEW_READ_TEST] = 0x02F4,
211 [PWRAP_DEW_WRITE_TEST] = 0x02F6,
212 [PWRAP_DEW_CRC_EN] = 0x02FA,
213 [PWRAP_DEW_CRC_VAL] = 0x02FC,
214 [PWRAP_DEW_CIPHER_KEY_SEL] = 0x0300,
215 [PWRAP_DEW_CIPHER_IV_SEL] = 0x0302,
216 [PWRAP_DEW_CIPHER_EN] = 0x0304,
217 [PWRAP_DEW_CIPHER_RDY] = 0x0306,
218 [PWRAP_DEW_CIPHER_MODE] = 0x0308,
219 [PWRAP_DEW_CIPHER_SWRST] = 0x030A,
220 [PWRAP_DEW_RDDMY_NO] = 0x030C,
221 };
222
223 static const u32 mt6357_regs[] = {
224 [PWRAP_DEW_DIO_EN] = 0x040A,
225 [PWRAP_DEW_READ_TEST] = 0x040C,
226 [PWRAP_DEW_WRITE_TEST] = 0x040E,
227 [PWRAP_DEW_CRC_EN] = 0x0412,
228 [PWRAP_DEW_CRC_VAL] = 0x0414,
229 [PWRAP_DEW_CIPHER_KEY_SEL] = 0x0418,
230 [PWRAP_DEW_CIPHER_IV_SEL] = 0x041A,
231 [PWRAP_DEW_CIPHER_EN] = 0x041C,
232 [PWRAP_DEW_CIPHER_RDY] = 0x041E,
233 [PWRAP_DEW_CIPHER_MODE] = 0x0420,
234 [PWRAP_DEW_CIPHER_SWRST] = 0x0422,
235 [PWRAP_DEW_RDDMY_NO] = 0x0424,
236 };
237
238 static const u32 mt6358_regs[] = {
239 [PWRAP_SMT_CON1] = 0x0030,
240 [PWRAP_DRV_CON1] = 0x0038,
241 [PWRAP_FILTER_CON0] = 0x0040,
242 [PWRAP_GPIO_PULLEN0_CLR] = 0x0098,
243 [PWRAP_RG_SPI_CON0] = 0x0408,
244 [PWRAP_RG_SPI_RECORD0] = 0x040a,
245 [PWRAP_DEW_DIO_EN] = 0x040c,
246 [PWRAP_DEW_READ_TEST] = 0x040e,
247 [PWRAP_DEW_WRITE_TEST] = 0x0410,
248 [PWRAP_DEW_CRC_EN] = 0x0414,
249 [PWRAP_DEW_CIPHER_KEY_SEL] = 0x041a,
250 [PWRAP_DEW_CIPHER_IV_SEL] = 0x041c,
251 [PWRAP_DEW_CIPHER_EN] = 0x041e,
252 [PWRAP_DEW_CIPHER_RDY] = 0x0420,
253 [PWRAP_DEW_CIPHER_MODE] = 0x0422,
254 [PWRAP_DEW_CIPHER_SWRST] = 0x0424,
255 [PWRAP_RG_SPI_CON2] = 0x0432,
256 [PWRAP_RG_SPI_CON3] = 0x0434,
257 [PWRAP_RG_SPI_CON4] = 0x0436,
258 [PWRAP_RG_SPI_CON5] = 0x0438,
259 [PWRAP_RG_SPI_CON6] = 0x043a,
260 [PWRAP_RG_SPI_CON7] = 0x043c,
261 [PWRAP_RG_SPI_CON8] = 0x043e,
262 [PWRAP_RG_SPI_CON13] = 0x0448,
263 [PWRAP_SPISLV_KEY] = 0x044a,
264 };
265
266 static const u32 mt6359_regs[] = {
267 [PWRAP_DEW_RG_EN_RECORD] = 0x040a,
268 [PWRAP_DEW_DIO_EN] = 0x040c,
269 [PWRAP_DEW_READ_TEST] = 0x040e,
270 [PWRAP_DEW_WRITE_TEST] = 0x0410,
271 [PWRAP_DEW_CRC_SWRST] = 0x0412,
272 [PWRAP_DEW_CRC_EN] = 0x0414,
273 [PWRAP_DEW_CRC_VAL] = 0x0416,
274 [PWRAP_DEW_CIPHER_KEY_SEL] = 0x0418,
275 [PWRAP_DEW_CIPHER_IV_SEL] = 0x041a,
276 [PWRAP_DEW_CIPHER_EN] = 0x041c,
277 [PWRAP_DEW_CIPHER_RDY] = 0x041e,
278 [PWRAP_DEW_CIPHER_MODE] = 0x0420,
279 [PWRAP_DEW_CIPHER_SWRST] = 0x0422,
280 [PWRAP_DEW_RDDMY_NO] = 0x0424,
281 [PWRAP_DEW_RECORD_CMD0] = 0x0428,
282 [PWRAP_DEW_RECORD_CMD1] = 0x042a,
283 [PWRAP_DEW_RECORD_CMD2] = 0x042c,
284 [PWRAP_DEW_RECORD_CMD3] = 0x042e,
285 [PWRAP_DEW_RECORD_CMD4] = 0x0430,
286 [PWRAP_DEW_RECORD_CMD5] = 0x0432,
287 [PWRAP_DEW_RECORD_WDATA0] = 0x0434,
288 [PWRAP_DEW_RECORD_WDATA1] = 0x0436,
289 [PWRAP_DEW_RECORD_WDATA2] = 0x0438,
290 [PWRAP_DEW_RECORD_WDATA3] = 0x043a,
291 [PWRAP_DEW_RECORD_WDATA4] = 0x043c,
292 [PWRAP_DEW_RECORD_WDATA5] = 0x043e,
293 [PWRAP_DEW_RG_ADDR_TARGET] = 0x0440,
294 [PWRAP_DEW_RG_ADDR_MASK] = 0x0442,
295 [PWRAP_DEW_RG_WDATA_TARGET] = 0x0444,
296 [PWRAP_DEW_RG_WDATA_MASK] = 0x0446,
297 [PWRAP_DEW_RG_SPI_RECORD_CLR] = 0x0448,
298 [PWRAP_DEW_RG_CMD_ALERT_CLR] = 0x0448,
299 [PWRAP_SPISLV_KEY] = 0x044a,
300 };
301
302 static const u32 mt6397_regs[] = {
303 [PWRAP_DEW_BASE] = 0xbc00,
304 [PWRAP_DEW_EVENT_OUT_EN] = 0xbc00,
305 [PWRAP_DEW_DIO_EN] = 0xbc02,
306 [PWRAP_DEW_EVENT_SRC_EN] = 0xbc04,
307 [PWRAP_DEW_EVENT_SRC] = 0xbc06,
308 [PWRAP_DEW_EVENT_FLAG] = 0xbc08,
309 [PWRAP_DEW_READ_TEST] = 0xbc0a,
310 [PWRAP_DEW_WRITE_TEST] = 0xbc0c,
311 [PWRAP_DEW_CRC_EN] = 0xbc0e,
312 [PWRAP_DEW_CRC_VAL] = 0xbc10,
313 [PWRAP_DEW_MON_GRP_SEL] = 0xbc12,
314 [PWRAP_DEW_MON_FLAG_SEL] = 0xbc14,
315 [PWRAP_DEW_EVENT_TEST] = 0xbc16,
316 [PWRAP_DEW_CIPHER_KEY_SEL] = 0xbc18,
317 [PWRAP_DEW_CIPHER_IV_SEL] = 0xbc1a,
318 [PWRAP_DEW_CIPHER_LOAD] = 0xbc1c,
319 [PWRAP_DEW_CIPHER_START] = 0xbc1e,
320 [PWRAP_DEW_CIPHER_RDY] = 0xbc20,
321 [PWRAP_DEW_CIPHER_MODE] = 0xbc22,
322 [PWRAP_DEW_CIPHER_SWRST] = 0xbc24,
323 };
324
325 enum pwrap_regs {
326 PWRAP_MUX_SEL,
327 PWRAP_WRAP_EN,
328 PWRAP_DIO_EN,
329 PWRAP_SIDLY,
330 PWRAP_CSHEXT_WRITE,
331 PWRAP_CSHEXT_READ,
332 PWRAP_CSLEXT_START,
333 PWRAP_CSLEXT_END,
334 PWRAP_STAUPD_PRD,
335 PWRAP_STAUPD_GRPEN,
336 PWRAP_STAUPD_MAN_TRIG,
337 PWRAP_STAUPD_STA,
338 PWRAP_WRAP_STA,
339 PWRAP_HARB_INIT,
340 PWRAP_HARB_HPRIO,
341 PWRAP_HIPRIO_ARB_EN,
342 PWRAP_HARB_STA0,
343 PWRAP_HARB_STA1,
344 PWRAP_MAN_EN,
345 PWRAP_MAN_CMD,
346 PWRAP_MAN_RDATA,
347 PWRAP_MAN_VLDCLR,
348 PWRAP_WACS0_EN,
349 PWRAP_INIT_DONE0,
350 PWRAP_WACS0_CMD,
351 PWRAP_WACS0_RDATA,
352 PWRAP_WACS0_VLDCLR,
353 PWRAP_WACS1_EN,
354 PWRAP_INIT_DONE1,
355 PWRAP_WACS1_CMD,
356 PWRAP_WACS1_RDATA,
357 PWRAP_WACS1_VLDCLR,
358 PWRAP_WACS2_EN,
359 PWRAP_INIT_DONE2,
360 PWRAP_WACS2_CMD,
361 PWRAP_WACS2_RDATA,
362 PWRAP_WACS2_VLDCLR,
363 PWRAP_INT_EN,
364 PWRAP_INT_FLG_RAW,
365 PWRAP_INT_FLG,
366 PWRAP_INT_CLR,
367 PWRAP_SIG_ADR,
368 PWRAP_SIG_MODE,
369 PWRAP_SIG_VALUE,
370 PWRAP_SIG_ERRVAL,
371 PWRAP_CRC_EN,
372 PWRAP_TIMER_EN,
373 PWRAP_TIMER_STA,
374 PWRAP_WDT_UNIT,
375 PWRAP_WDT_SRC_EN,
376 PWRAP_WDT_FLG,
377 PWRAP_DEBUG_INT_SEL,
378 PWRAP_CIPHER_KEY_SEL,
379 PWRAP_CIPHER_IV_SEL,
380 PWRAP_CIPHER_RDY,
381 PWRAP_CIPHER_MODE,
382 PWRAP_CIPHER_SWRST,
383 PWRAP_DCM_EN,
384 PWRAP_DCM_DBC_PRD,
385 PWRAP_EINT_STA0_ADR,
386 PWRAP_EINT_STA1_ADR,
387 PWRAP_SWINF_2_WDATA_31_0,
388 PWRAP_SWINF_2_RDATA_31_0,
389
390 /* MT2701 only regs */
391 PWRAP_ADC_CMD_ADDR,
392 PWRAP_PWRAP_ADC_CMD,
393 PWRAP_ADC_RDY_ADDR,
394 PWRAP_ADC_RDATA_ADDR1,
395 PWRAP_ADC_RDATA_ADDR2,
396
397 /* MT7622 only regs */
398 PWRAP_STA,
399 PWRAP_CLR,
400 PWRAP_DVFS_ADR8,
401 PWRAP_DVFS_WDATA8,
402 PWRAP_DVFS_ADR9,
403 PWRAP_DVFS_WDATA9,
404 PWRAP_DVFS_ADR10,
405 PWRAP_DVFS_WDATA10,
406 PWRAP_DVFS_ADR11,
407 PWRAP_DVFS_WDATA11,
408 PWRAP_DVFS_ADR12,
409 PWRAP_DVFS_WDATA12,
410 PWRAP_DVFS_ADR13,
411 PWRAP_DVFS_WDATA13,
412 PWRAP_DVFS_ADR14,
413 PWRAP_DVFS_WDATA14,
414 PWRAP_DVFS_ADR15,
415 PWRAP_DVFS_WDATA15,
416 PWRAP_EXT_CK,
417 PWRAP_ADC_RDATA_ADDR,
418 PWRAP_GPS_STA,
419 PWRAP_SW_RST,
420 PWRAP_DVFS_STEP_CTRL0,
421 PWRAP_DVFS_STEP_CTRL1,
422 PWRAP_DVFS_STEP_CTRL2,
423 PWRAP_SPI2_CTRL,
424
425 /* MT8135 only regs */
426 PWRAP_CSHEXT,
427 PWRAP_EVENT_IN_EN,
428 PWRAP_EVENT_DST_EN,
429 PWRAP_RRARB_INIT,
430 PWRAP_RRARB_EN,
431 PWRAP_RRARB_STA0,
432 PWRAP_RRARB_STA1,
433 PWRAP_EVENT_STA,
434 PWRAP_EVENT_STACLR,
435 PWRAP_CIPHER_LOAD,
436 PWRAP_CIPHER_START,
437
438 /* MT8173 only regs */
439 PWRAP_RDDMY,
440 PWRAP_SI_CK_CON,
441 PWRAP_DVFS_ADR0,
442 PWRAP_DVFS_WDATA0,
443 PWRAP_DVFS_ADR1,
444 PWRAP_DVFS_WDATA1,
445 PWRAP_DVFS_ADR2,
446 PWRAP_DVFS_WDATA2,
447 PWRAP_DVFS_ADR3,
448 PWRAP_DVFS_WDATA3,
449 PWRAP_DVFS_ADR4,
450 PWRAP_DVFS_WDATA4,
451 PWRAP_DVFS_ADR5,
452 PWRAP_DVFS_WDATA5,
453 PWRAP_DVFS_ADR6,
454 PWRAP_DVFS_WDATA6,
455 PWRAP_DVFS_ADR7,
456 PWRAP_DVFS_WDATA7,
457 PWRAP_SPMINF_STA,
458 PWRAP_CIPHER_EN,
459
460 /* MT8183 only regs */
461 PWRAP_SI_SAMPLE_CTRL,
462 PWRAP_CSLEXT_WRITE,
463 PWRAP_CSLEXT_READ,
464 PWRAP_EXT_CK_WRITE,
465 PWRAP_STAUPD_CTRL,
466 PWRAP_WACS_P2P_EN,
467 PWRAP_INIT_DONE_P2P,
468 PWRAP_WACS_MD32_EN,
469 PWRAP_INIT_DONE_MD32,
470 PWRAP_INT1_EN,
471 PWRAP_INT1_FLG,
472 PWRAP_INT1_CLR,
473 PWRAP_WDT_SRC_EN_1,
474 PWRAP_INT_GPS_AUXADC_CMD_ADDR,
475 PWRAP_INT_GPS_AUXADC_CMD,
476 PWRAP_INT_GPS_AUXADC_RDATA_ADDR,
477 PWRAP_EXT_GPS_AUXADC_RDATA_ADDR,
478 PWRAP_GPSINF_0_STA,
479 PWRAP_GPSINF_1_STA,
480
481 /* MT8516 only regs */
482 PWRAP_OP_TYPE,
483 PWRAP_MSB_FIRST,
484 };
485
486 static const int mt2701_regs[] = {
487 [PWRAP_MUX_SEL] = 0x0,
488 [PWRAP_WRAP_EN] = 0x4,
489 [PWRAP_DIO_EN] = 0x8,
490 [PWRAP_SIDLY] = 0xc,
491 [PWRAP_RDDMY] = 0x18,
492 [PWRAP_SI_CK_CON] = 0x1c,
493 [PWRAP_CSHEXT_WRITE] = 0x20,
494 [PWRAP_CSHEXT_READ] = 0x24,
495 [PWRAP_CSLEXT_START] = 0x28,
496 [PWRAP_CSLEXT_END] = 0x2c,
497 [PWRAP_STAUPD_PRD] = 0x30,
498 [PWRAP_STAUPD_GRPEN] = 0x34,
499 [PWRAP_STAUPD_MAN_TRIG] = 0x38,
500 [PWRAP_STAUPD_STA] = 0x3c,
501 [PWRAP_WRAP_STA] = 0x44,
502 [PWRAP_HARB_INIT] = 0x48,
503 [PWRAP_HARB_HPRIO] = 0x4c,
504 [PWRAP_HIPRIO_ARB_EN] = 0x50,
505 [PWRAP_HARB_STA0] = 0x54,
506 [PWRAP_HARB_STA1] = 0x58,
507 [PWRAP_MAN_EN] = 0x5c,
508 [PWRAP_MAN_CMD] = 0x60,
509 [PWRAP_MAN_RDATA] = 0x64,
510 [PWRAP_MAN_VLDCLR] = 0x68,
511 [PWRAP_WACS0_EN] = 0x6c,
512 [PWRAP_INIT_DONE0] = 0x70,
513 [PWRAP_WACS0_CMD] = 0x74,
514 [PWRAP_WACS0_RDATA] = 0x78,
515 [PWRAP_WACS0_VLDCLR] = 0x7c,
516 [PWRAP_WACS1_EN] = 0x80,
517 [PWRAP_INIT_DONE1] = 0x84,
518 [PWRAP_WACS1_CMD] = 0x88,
519 [PWRAP_WACS1_RDATA] = 0x8c,
520 [PWRAP_WACS1_VLDCLR] = 0x90,
521 [PWRAP_WACS2_EN] = 0x94,
522 [PWRAP_INIT_DONE2] = 0x98,
523 [PWRAP_WACS2_CMD] = 0x9c,
524 [PWRAP_WACS2_RDATA] = 0xa0,
525 [PWRAP_WACS2_VLDCLR] = 0xa4,
526 [PWRAP_INT_EN] = 0xa8,
527 [PWRAP_INT_FLG_RAW] = 0xac,
528 [PWRAP_INT_FLG] = 0xb0,
529 [PWRAP_INT_CLR] = 0xb4,
530 [PWRAP_SIG_ADR] = 0xb8,
531 [PWRAP_SIG_MODE] = 0xbc,
532 [PWRAP_SIG_VALUE] = 0xc0,
533 [PWRAP_SIG_ERRVAL] = 0xc4,
534 [PWRAP_CRC_EN] = 0xc8,
535 [PWRAP_TIMER_EN] = 0xcc,
536 [PWRAP_TIMER_STA] = 0xd0,
537 [PWRAP_WDT_UNIT] = 0xd4,
538 [PWRAP_WDT_SRC_EN] = 0xd8,
539 [PWRAP_WDT_FLG] = 0xdc,
540 [PWRAP_DEBUG_INT_SEL] = 0xe0,
541 [PWRAP_DVFS_ADR0] = 0xe4,
542 [PWRAP_DVFS_WDATA0] = 0xe8,
543 [PWRAP_DVFS_ADR1] = 0xec,
544 [PWRAP_DVFS_WDATA1] = 0xf0,
545 [PWRAP_DVFS_ADR2] = 0xf4,
546 [PWRAP_DVFS_WDATA2] = 0xf8,
547 [PWRAP_DVFS_ADR3] = 0xfc,
548 [PWRAP_DVFS_WDATA3] = 0x100,
549 [PWRAP_DVFS_ADR4] = 0x104,
550 [PWRAP_DVFS_WDATA4] = 0x108,
551 [PWRAP_DVFS_ADR5] = 0x10c,
552 [PWRAP_DVFS_WDATA5] = 0x110,
553 [PWRAP_DVFS_ADR6] = 0x114,
554 [PWRAP_DVFS_WDATA6] = 0x118,
555 [PWRAP_DVFS_ADR7] = 0x11c,
556 [PWRAP_DVFS_WDATA7] = 0x120,
557 [PWRAP_CIPHER_KEY_SEL] = 0x124,
558 [PWRAP_CIPHER_IV_SEL] = 0x128,
559 [PWRAP_CIPHER_EN] = 0x12c,
560 [PWRAP_CIPHER_RDY] = 0x130,
561 [PWRAP_CIPHER_MODE] = 0x134,
562 [PWRAP_CIPHER_SWRST] = 0x138,
563 [PWRAP_DCM_EN] = 0x13c,
564 [PWRAP_DCM_DBC_PRD] = 0x140,
565 [PWRAP_ADC_CMD_ADDR] = 0x144,
566 [PWRAP_PWRAP_ADC_CMD] = 0x148,
567 [PWRAP_ADC_RDY_ADDR] = 0x14c,
568 [PWRAP_ADC_RDATA_ADDR1] = 0x150,
569 [PWRAP_ADC_RDATA_ADDR2] = 0x154,
570 };
571
572 static const int mt6765_regs[] = {
573 [PWRAP_MUX_SEL] = 0x0,
574 [PWRAP_WRAP_EN] = 0x4,
575 [PWRAP_DIO_EN] = 0x8,
576 [PWRAP_RDDMY] = 0x20,
577 [PWRAP_CSHEXT_WRITE] = 0x24,
578 [PWRAP_CSHEXT_READ] = 0x28,
579 [PWRAP_CSLEXT_START] = 0x2C,
580 [PWRAP_CSLEXT_END] = 0x30,
581 [PWRAP_STAUPD_PRD] = 0x3C,
582 [PWRAP_HARB_HPRIO] = 0x68,
583 [PWRAP_HIPRIO_ARB_EN] = 0x6C,
584 [PWRAP_MAN_EN] = 0x7C,
585 [PWRAP_MAN_CMD] = 0x80,
586 [PWRAP_WACS0_EN] = 0x8C,
587 [PWRAP_WACS1_EN] = 0x94,
588 [PWRAP_WACS2_EN] = 0x9C,
589 [PWRAP_INIT_DONE2] = 0xA0,
590 [PWRAP_WACS2_CMD] = 0xC20,
591 [PWRAP_WACS2_RDATA] = 0xC24,
592 [PWRAP_WACS2_VLDCLR] = 0xC28,
593 [PWRAP_INT_EN] = 0xB4,
594 [PWRAP_INT_FLG_RAW] = 0xB8,
595 [PWRAP_INT_FLG] = 0xBC,
596 [PWRAP_INT_CLR] = 0xC0,
597 [PWRAP_TIMER_EN] = 0xE8,
598 [PWRAP_WDT_UNIT] = 0xF0,
599 [PWRAP_WDT_SRC_EN] = 0xF4,
600 [PWRAP_DCM_EN] = 0x1DC,
601 [PWRAP_DCM_DBC_PRD] = 0x1E0,
602 };
603
604 static const int mt6779_regs[] = {
605 [PWRAP_MUX_SEL] = 0x0,
606 [PWRAP_WRAP_EN] = 0x4,
607 [PWRAP_DIO_EN] = 0x8,
608 [PWRAP_RDDMY] = 0x20,
609 [PWRAP_CSHEXT_WRITE] = 0x24,
610 [PWRAP_CSHEXT_READ] = 0x28,
611 [PWRAP_CSLEXT_WRITE] = 0x2C,
612 [PWRAP_CSLEXT_READ] = 0x30,
613 [PWRAP_EXT_CK_WRITE] = 0x34,
614 [PWRAP_STAUPD_CTRL] = 0x3C,
615 [PWRAP_STAUPD_GRPEN] = 0x40,
616 [PWRAP_EINT_STA0_ADR] = 0x44,
617 [PWRAP_HARB_HPRIO] = 0x68,
618 [PWRAP_HIPRIO_ARB_EN] = 0x6C,
619 [PWRAP_MAN_EN] = 0x7C,
620 [PWRAP_MAN_CMD] = 0x80,
621 [PWRAP_WACS0_EN] = 0x8C,
622 [PWRAP_INIT_DONE0] = 0x90,
623 [PWRAP_WACS1_EN] = 0x94,
624 [PWRAP_WACS2_EN] = 0x9C,
625 [PWRAP_INIT_DONE1] = 0x98,
626 [PWRAP_INIT_DONE2] = 0xA0,
627 [PWRAP_INT_EN] = 0xBC,
628 [PWRAP_INT_FLG_RAW] = 0xC0,
629 [PWRAP_INT_FLG] = 0xC4,
630 [PWRAP_INT_CLR] = 0xC8,
631 [PWRAP_INT1_EN] = 0xCC,
632 [PWRAP_INT1_FLG] = 0xD4,
633 [PWRAP_INT1_CLR] = 0xD8,
634 [PWRAP_TIMER_EN] = 0xF0,
635 [PWRAP_WDT_UNIT] = 0xF8,
636 [PWRAP_WDT_SRC_EN] = 0xFC,
637 [PWRAP_WDT_SRC_EN_1] = 0x100,
638 [PWRAP_WACS2_CMD] = 0xC20,
639 [PWRAP_WACS2_RDATA] = 0xC24,
640 [PWRAP_WACS2_VLDCLR] = 0xC28,
641 };
642
643 static const int mt6795_regs[] = {
644 [PWRAP_MUX_SEL] = 0x0,
645 [PWRAP_WRAP_EN] = 0x4,
646 [PWRAP_DIO_EN] = 0x8,
647 [PWRAP_SIDLY] = 0xc,
648 [PWRAP_RDDMY] = 0x10,
649 [PWRAP_SI_CK_CON] = 0x14,
650 [PWRAP_CSHEXT_WRITE] = 0x18,
651 [PWRAP_CSHEXT_READ] = 0x1c,
652 [PWRAP_CSLEXT_START] = 0x20,
653 [PWRAP_CSLEXT_END] = 0x24,
654 [PWRAP_STAUPD_PRD] = 0x28,
655 [PWRAP_STAUPD_GRPEN] = 0x2c,
656 [PWRAP_EINT_STA0_ADR] = 0x30,
657 [PWRAP_EINT_STA1_ADR] = 0x34,
658 [PWRAP_STAUPD_MAN_TRIG] = 0x40,
659 [PWRAP_STAUPD_STA] = 0x44,
660 [PWRAP_WRAP_STA] = 0x48,
661 [PWRAP_HARB_INIT] = 0x4c,
662 [PWRAP_HARB_HPRIO] = 0x50,
663 [PWRAP_HIPRIO_ARB_EN] = 0x54,
664 [PWRAP_HARB_STA0] = 0x58,
665 [PWRAP_HARB_STA1] = 0x5c,
666 [PWRAP_MAN_EN] = 0x60,
667 [PWRAP_MAN_CMD] = 0x64,
668 [PWRAP_MAN_RDATA] = 0x68,
669 [PWRAP_MAN_VLDCLR] = 0x6c,
670 [PWRAP_WACS0_EN] = 0x70,
671 [PWRAP_INIT_DONE0] = 0x74,
672 [PWRAP_WACS0_CMD] = 0x78,
673 [PWRAP_WACS0_RDATA] = 0x7c,
674 [PWRAP_WACS0_VLDCLR] = 0x80,
675 [PWRAP_WACS1_EN] = 0x84,
676 [PWRAP_INIT_DONE1] = 0x88,
677 [PWRAP_WACS1_CMD] = 0x8c,
678 [PWRAP_WACS1_RDATA] = 0x90,
679 [PWRAP_WACS1_VLDCLR] = 0x94,
680 [PWRAP_WACS2_EN] = 0x98,
681 [PWRAP_INIT_DONE2] = 0x9c,
682 [PWRAP_WACS2_CMD] = 0xa0,
683 [PWRAP_WACS2_RDATA] = 0xa4,
684 [PWRAP_WACS2_VLDCLR] = 0xa8,
685 [PWRAP_INT_EN] = 0xac,
686 [PWRAP_INT_FLG_RAW] = 0xb0,
687 [PWRAP_INT_FLG] = 0xb4,
688 [PWRAP_INT_CLR] = 0xb8,
689 [PWRAP_SIG_ADR] = 0xbc,
690 [PWRAP_SIG_MODE] = 0xc0,
691 [PWRAP_SIG_VALUE] = 0xc4,
692 [PWRAP_SIG_ERRVAL] = 0xc8,
693 [PWRAP_CRC_EN] = 0xcc,
694 [PWRAP_TIMER_EN] = 0xd0,
695 [PWRAP_TIMER_STA] = 0xd4,
696 [PWRAP_WDT_UNIT] = 0xd8,
697 [PWRAP_WDT_SRC_EN] = 0xdc,
698 [PWRAP_WDT_FLG] = 0xe0,
699 [PWRAP_DEBUG_INT_SEL] = 0xe4,
700 [PWRAP_DVFS_ADR0] = 0xe8,
701 [PWRAP_DVFS_WDATA0] = 0xec,
702 [PWRAP_DVFS_ADR1] = 0xf0,
703 [PWRAP_DVFS_WDATA1] = 0xf4,
704 [PWRAP_DVFS_ADR2] = 0xf8,
705 [PWRAP_DVFS_WDATA2] = 0xfc,
706 [PWRAP_DVFS_ADR3] = 0x100,
707 [PWRAP_DVFS_WDATA3] = 0x104,
708 [PWRAP_DVFS_ADR4] = 0x108,
709 [PWRAP_DVFS_WDATA4] = 0x10c,
710 [PWRAP_DVFS_ADR5] = 0x110,
711 [PWRAP_DVFS_WDATA5] = 0x114,
712 [PWRAP_DVFS_ADR6] = 0x118,
713 [PWRAP_DVFS_WDATA6] = 0x11c,
714 [PWRAP_DVFS_ADR7] = 0x120,
715 [PWRAP_DVFS_WDATA7] = 0x124,
716 [PWRAP_SPMINF_STA] = 0x128,
717 [PWRAP_CIPHER_KEY_SEL] = 0x12c,
718 [PWRAP_CIPHER_IV_SEL] = 0x130,
719 [PWRAP_CIPHER_EN] = 0x134,
720 [PWRAP_CIPHER_RDY] = 0x138,
721 [PWRAP_CIPHER_MODE] = 0x13c,
722 [PWRAP_CIPHER_SWRST] = 0x140,
723 [PWRAP_DCM_EN] = 0x144,
724 [PWRAP_DCM_DBC_PRD] = 0x148,
725 [PWRAP_EXT_CK] = 0x14c,
726 };
727
728 static const int mt6797_regs[] = {
729 [PWRAP_MUX_SEL] = 0x0,
730 [PWRAP_WRAP_EN] = 0x4,
731 [PWRAP_DIO_EN] = 0x8,
732 [PWRAP_SIDLY] = 0xC,
733 [PWRAP_RDDMY] = 0x10,
734 [PWRAP_CSHEXT_WRITE] = 0x18,
735 [PWRAP_CSHEXT_READ] = 0x1C,
736 [PWRAP_CSLEXT_START] = 0x20,
737 [PWRAP_CSLEXT_END] = 0x24,
738 [PWRAP_STAUPD_PRD] = 0x28,
739 [PWRAP_HARB_HPRIO] = 0x50,
740 [PWRAP_HIPRIO_ARB_EN] = 0x54,
741 [PWRAP_MAN_EN] = 0x60,
742 [PWRAP_MAN_CMD] = 0x64,
743 [PWRAP_WACS0_EN] = 0x70,
744 [PWRAP_WACS1_EN] = 0x84,
745 [PWRAP_WACS2_EN] = 0x98,
746 [PWRAP_INIT_DONE2] = 0x9C,
747 [PWRAP_WACS2_CMD] = 0xA0,
748 [PWRAP_WACS2_RDATA] = 0xA4,
749 [PWRAP_WACS2_VLDCLR] = 0xA8,
750 [PWRAP_INT_EN] = 0xC0,
751 [PWRAP_INT_FLG_RAW] = 0xC4,
752 [PWRAP_INT_FLG] = 0xC8,
753 [PWRAP_INT_CLR] = 0xCC,
754 [PWRAP_TIMER_EN] = 0xF4,
755 [PWRAP_WDT_UNIT] = 0xFC,
756 [PWRAP_WDT_SRC_EN] = 0x100,
757 [PWRAP_DCM_EN] = 0x1CC,
758 [PWRAP_DCM_DBC_PRD] = 0x1D4,
759 };
760
761 static const int mt6873_regs[] = {
762 [PWRAP_INIT_DONE2] = 0x0,
763 [PWRAP_TIMER_EN] = 0x3E0,
764 [PWRAP_INT_EN] = 0x448,
765 [PWRAP_WACS2_CMD] = 0xC80,
766 [PWRAP_SWINF_2_WDATA_31_0] = 0xC84,
767 [PWRAP_SWINF_2_RDATA_31_0] = 0xC94,
768 [PWRAP_WACS2_VLDCLR] = 0xCA4,
769 [PWRAP_WACS2_RDATA] = 0xCA8,
770 };
771
772 static const int mt7622_regs[] = {
773 [PWRAP_MUX_SEL] = 0x0,
774 [PWRAP_WRAP_EN] = 0x4,
775 [PWRAP_DIO_EN] = 0x8,
776 [PWRAP_SIDLY] = 0xC,
777 [PWRAP_RDDMY] = 0x10,
778 [PWRAP_SI_CK_CON] = 0x14,
779 [PWRAP_CSHEXT_WRITE] = 0x18,
780 [PWRAP_CSHEXT_READ] = 0x1C,
781 [PWRAP_CSLEXT_START] = 0x20,
782 [PWRAP_CSLEXT_END] = 0x24,
783 [PWRAP_STAUPD_PRD] = 0x28,
784 [PWRAP_STAUPD_GRPEN] = 0x2C,
785 [PWRAP_EINT_STA0_ADR] = 0x30,
786 [PWRAP_EINT_STA1_ADR] = 0x34,
787 [PWRAP_STA] = 0x38,
788 [PWRAP_CLR] = 0x3C,
789 [PWRAP_STAUPD_MAN_TRIG] = 0x40,
790 [PWRAP_STAUPD_STA] = 0x44,
791 [PWRAP_WRAP_STA] = 0x48,
792 [PWRAP_HARB_INIT] = 0x4C,
793 [PWRAP_HARB_HPRIO] = 0x50,
794 [PWRAP_HIPRIO_ARB_EN] = 0x54,
795 [PWRAP_HARB_STA0] = 0x58,
796 [PWRAP_HARB_STA1] = 0x5C,
797 [PWRAP_MAN_EN] = 0x60,
798 [PWRAP_MAN_CMD] = 0x64,
799 [PWRAP_MAN_RDATA] = 0x68,
800 [PWRAP_MAN_VLDCLR] = 0x6C,
801 [PWRAP_WACS0_EN] = 0x70,
802 [PWRAP_INIT_DONE0] = 0x74,
803 [PWRAP_WACS0_CMD] = 0x78,
804 [PWRAP_WACS0_RDATA] = 0x7C,
805 [PWRAP_WACS0_VLDCLR] = 0x80,
806 [PWRAP_WACS1_EN] = 0x84,
807 [PWRAP_INIT_DONE1] = 0x88,
808 [PWRAP_WACS1_CMD] = 0x8C,
809 [PWRAP_WACS1_RDATA] = 0x90,
810 [PWRAP_WACS1_VLDCLR] = 0x94,
811 [PWRAP_WACS2_EN] = 0x98,
812 [PWRAP_INIT_DONE2] = 0x9C,
813 [PWRAP_WACS2_CMD] = 0xA0,
814 [PWRAP_WACS2_RDATA] = 0xA4,
815 [PWRAP_WACS2_VLDCLR] = 0xA8,
816 [PWRAP_INT_EN] = 0xAC,
817 [PWRAP_INT_FLG_RAW] = 0xB0,
818 [PWRAP_INT_FLG] = 0xB4,
819 [PWRAP_INT_CLR] = 0xB8,
820 [PWRAP_SIG_ADR] = 0xBC,
821 [PWRAP_SIG_MODE] = 0xC0,
822 [PWRAP_SIG_VALUE] = 0xC4,
823 [PWRAP_SIG_ERRVAL] = 0xC8,
824 [PWRAP_CRC_EN] = 0xCC,
825 [PWRAP_TIMER_EN] = 0xD0,
826 [PWRAP_TIMER_STA] = 0xD4,
827 [PWRAP_WDT_UNIT] = 0xD8,
828 [PWRAP_WDT_SRC_EN] = 0xDC,
829 [PWRAP_WDT_FLG] = 0xE0,
830 [PWRAP_DEBUG_INT_SEL] = 0xE4,
831 [PWRAP_DVFS_ADR0] = 0xE8,
832 [PWRAP_DVFS_WDATA0] = 0xEC,
833 [PWRAP_DVFS_ADR1] = 0xF0,
834 [PWRAP_DVFS_WDATA1] = 0xF4,
835 [PWRAP_DVFS_ADR2] = 0xF8,
836 [PWRAP_DVFS_WDATA2] = 0xFC,
837 [PWRAP_DVFS_ADR3] = 0x100,
838 [PWRAP_DVFS_WDATA3] = 0x104,
839 [PWRAP_DVFS_ADR4] = 0x108,
840 [PWRAP_DVFS_WDATA4] = 0x10C,
841 [PWRAP_DVFS_ADR5] = 0x110,
842 [PWRAP_DVFS_WDATA5] = 0x114,
843 [PWRAP_DVFS_ADR6] = 0x118,
844 [PWRAP_DVFS_WDATA6] = 0x11C,
845 [PWRAP_DVFS_ADR7] = 0x120,
846 [PWRAP_DVFS_WDATA7] = 0x124,
847 [PWRAP_DVFS_ADR8] = 0x128,
848 [PWRAP_DVFS_WDATA8] = 0x12C,
849 [PWRAP_DVFS_ADR9] = 0x130,
850 [PWRAP_DVFS_WDATA9] = 0x134,
851 [PWRAP_DVFS_ADR10] = 0x138,
852 [PWRAP_DVFS_WDATA10] = 0x13C,
853 [PWRAP_DVFS_ADR11] = 0x140,
854 [PWRAP_DVFS_WDATA11] = 0x144,
855 [PWRAP_DVFS_ADR12] = 0x148,
856 [PWRAP_DVFS_WDATA12] = 0x14C,
857 [PWRAP_DVFS_ADR13] = 0x150,
858 [PWRAP_DVFS_WDATA13] = 0x154,
859 [PWRAP_DVFS_ADR14] = 0x158,
860 [PWRAP_DVFS_WDATA14] = 0x15C,
861 [PWRAP_DVFS_ADR15] = 0x160,
862 [PWRAP_DVFS_WDATA15] = 0x164,
863 [PWRAP_SPMINF_STA] = 0x168,
864 [PWRAP_CIPHER_KEY_SEL] = 0x16C,
865 [PWRAP_CIPHER_IV_SEL] = 0x170,
866 [PWRAP_CIPHER_EN] = 0x174,
867 [PWRAP_CIPHER_RDY] = 0x178,
868 [PWRAP_CIPHER_MODE] = 0x17C,
869 [PWRAP_CIPHER_SWRST] = 0x180,
870 [PWRAP_DCM_EN] = 0x184,
871 [PWRAP_DCM_DBC_PRD] = 0x188,
872 [PWRAP_EXT_CK] = 0x18C,
873 [PWRAP_ADC_CMD_ADDR] = 0x190,
874 [PWRAP_PWRAP_ADC_CMD] = 0x194,
875 [PWRAP_ADC_RDATA_ADDR] = 0x198,
876 [PWRAP_GPS_STA] = 0x19C,
877 [PWRAP_SW_RST] = 0x1A0,
878 [PWRAP_DVFS_STEP_CTRL0] = 0x238,
879 [PWRAP_DVFS_STEP_CTRL1] = 0x23C,
880 [PWRAP_DVFS_STEP_CTRL2] = 0x240,
881 [PWRAP_SPI2_CTRL] = 0x244,
882 };
883
884 static const int mt8135_regs[] = {
885 [PWRAP_MUX_SEL] = 0x0,
886 [PWRAP_WRAP_EN] = 0x4,
887 [PWRAP_DIO_EN] = 0x8,
888 [PWRAP_SIDLY] = 0xc,
889 [PWRAP_CSHEXT] = 0x10,
890 [PWRAP_CSHEXT_WRITE] = 0x14,
891 [PWRAP_CSHEXT_READ] = 0x18,
892 [PWRAP_CSLEXT_START] = 0x1c,
893 [PWRAP_CSLEXT_END] = 0x20,
894 [PWRAP_STAUPD_PRD] = 0x24,
895 [PWRAP_STAUPD_GRPEN] = 0x28,
896 [PWRAP_STAUPD_MAN_TRIG] = 0x2c,
897 [PWRAP_STAUPD_STA] = 0x30,
898 [PWRAP_EVENT_IN_EN] = 0x34,
899 [PWRAP_EVENT_DST_EN] = 0x38,
900 [PWRAP_WRAP_STA] = 0x3c,
901 [PWRAP_RRARB_INIT] = 0x40,
902 [PWRAP_RRARB_EN] = 0x44,
903 [PWRAP_RRARB_STA0] = 0x48,
904 [PWRAP_RRARB_STA1] = 0x4c,
905 [PWRAP_HARB_INIT] = 0x50,
906 [PWRAP_HARB_HPRIO] = 0x54,
907 [PWRAP_HIPRIO_ARB_EN] = 0x58,
908 [PWRAP_HARB_STA0] = 0x5c,
909 [PWRAP_HARB_STA1] = 0x60,
910 [PWRAP_MAN_EN] = 0x64,
911 [PWRAP_MAN_CMD] = 0x68,
912 [PWRAP_MAN_RDATA] = 0x6c,
913 [PWRAP_MAN_VLDCLR] = 0x70,
914 [PWRAP_WACS0_EN] = 0x74,
915 [PWRAP_INIT_DONE0] = 0x78,
916 [PWRAP_WACS0_CMD] = 0x7c,
917 [PWRAP_WACS0_RDATA] = 0x80,
918 [PWRAP_WACS0_VLDCLR] = 0x84,
919 [PWRAP_WACS1_EN] = 0x88,
920 [PWRAP_INIT_DONE1] = 0x8c,
921 [PWRAP_WACS1_CMD] = 0x90,
922 [PWRAP_WACS1_RDATA] = 0x94,
923 [PWRAP_WACS1_VLDCLR] = 0x98,
924 [PWRAP_WACS2_EN] = 0x9c,
925 [PWRAP_INIT_DONE2] = 0xa0,
926 [PWRAP_WACS2_CMD] = 0xa4,
927 [PWRAP_WACS2_RDATA] = 0xa8,
928 [PWRAP_WACS2_VLDCLR] = 0xac,
929 [PWRAP_INT_EN] = 0xb0,
930 [PWRAP_INT_FLG_RAW] = 0xb4,
931 [PWRAP_INT_FLG] = 0xb8,
932 [PWRAP_INT_CLR] = 0xbc,
933 [PWRAP_SIG_ADR] = 0xc0,
934 [PWRAP_SIG_MODE] = 0xc4,
935 [PWRAP_SIG_VALUE] = 0xc8,
936 [PWRAP_SIG_ERRVAL] = 0xcc,
937 [PWRAP_CRC_EN] = 0xd0,
938 [PWRAP_EVENT_STA] = 0xd4,
939 [PWRAP_EVENT_STACLR] = 0xd8,
940 [PWRAP_TIMER_EN] = 0xdc,
941 [PWRAP_TIMER_STA] = 0xe0,
942 [PWRAP_WDT_UNIT] = 0xe4,
943 [PWRAP_WDT_SRC_EN] = 0xe8,
944 [PWRAP_WDT_FLG] = 0xec,
945 [PWRAP_DEBUG_INT_SEL] = 0xf0,
946 [PWRAP_CIPHER_KEY_SEL] = 0x134,
947 [PWRAP_CIPHER_IV_SEL] = 0x138,
948 [PWRAP_CIPHER_LOAD] = 0x13c,
949 [PWRAP_CIPHER_START] = 0x140,
950 [PWRAP_CIPHER_RDY] = 0x144,
951 [PWRAP_CIPHER_MODE] = 0x148,
952 [PWRAP_CIPHER_SWRST] = 0x14c,
953 [PWRAP_DCM_EN] = 0x15c,
954 [PWRAP_DCM_DBC_PRD] = 0x160,
955 };
956
957 static const int mt8173_regs[] = {
958 [PWRAP_MUX_SEL] = 0x0,
959 [PWRAP_WRAP_EN] = 0x4,
960 [PWRAP_DIO_EN] = 0x8,
961 [PWRAP_SIDLY] = 0xc,
962 [PWRAP_RDDMY] = 0x10,
963 [PWRAP_SI_CK_CON] = 0x14,
964 [PWRAP_CSHEXT_WRITE] = 0x18,
965 [PWRAP_CSHEXT_READ] = 0x1c,
966 [PWRAP_CSLEXT_START] = 0x20,
967 [PWRAP_CSLEXT_END] = 0x24,
968 [PWRAP_STAUPD_PRD] = 0x28,
969 [PWRAP_STAUPD_GRPEN] = 0x2c,
970 [PWRAP_STAUPD_MAN_TRIG] = 0x40,
971 [PWRAP_STAUPD_STA] = 0x44,
972 [PWRAP_WRAP_STA] = 0x48,
973 [PWRAP_HARB_INIT] = 0x4c,
974 [PWRAP_HARB_HPRIO] = 0x50,
975 [PWRAP_HIPRIO_ARB_EN] = 0x54,
976 [PWRAP_HARB_STA0] = 0x58,
977 [PWRAP_HARB_STA1] = 0x5c,
978 [PWRAP_MAN_EN] = 0x60,
979 [PWRAP_MAN_CMD] = 0x64,
980 [PWRAP_MAN_RDATA] = 0x68,
981 [PWRAP_MAN_VLDCLR] = 0x6c,
982 [PWRAP_WACS0_EN] = 0x70,
983 [PWRAP_INIT_DONE0] = 0x74,
984 [PWRAP_WACS0_CMD] = 0x78,
985 [PWRAP_WACS0_RDATA] = 0x7c,
986 [PWRAP_WACS0_VLDCLR] = 0x80,
987 [PWRAP_WACS1_EN] = 0x84,
988 [PWRAP_INIT_DONE1] = 0x88,
989 [PWRAP_WACS1_CMD] = 0x8c,
990 [PWRAP_WACS1_RDATA] = 0x90,
991 [PWRAP_WACS1_VLDCLR] = 0x94,
992 [PWRAP_WACS2_EN] = 0x98,
993 [PWRAP_INIT_DONE2] = 0x9c,
994 [PWRAP_WACS2_CMD] = 0xa0,
995 [PWRAP_WACS2_RDATA] = 0xa4,
996 [PWRAP_WACS2_VLDCLR] = 0xa8,
997 [PWRAP_INT_EN] = 0xac,
998 [PWRAP_INT_FLG_RAW] = 0xb0,
999 [PWRAP_INT_FLG] = 0xb4,
1000 [PWRAP_INT_CLR] = 0xb8,
1001 [PWRAP_SIG_ADR] = 0xbc,
1002 [PWRAP_SIG_MODE] = 0xc0,
1003 [PWRAP_SIG_VALUE] = 0xc4,
1004 [PWRAP_SIG_ERRVAL] = 0xc8,
1005 [PWRAP_CRC_EN] = 0xcc,
1006 [PWRAP_TIMER_EN] = 0xd0,
1007 [PWRAP_TIMER_STA] = 0xd4,
1008 [PWRAP_WDT_UNIT] = 0xd8,
1009 [PWRAP_WDT_SRC_EN] = 0xdc,
1010 [PWRAP_WDT_FLG] = 0xe0,
1011 [PWRAP_DEBUG_INT_SEL] = 0xe4,
1012 [PWRAP_DVFS_ADR0] = 0xe8,
1013 [PWRAP_DVFS_WDATA0] = 0xec,
1014 [PWRAP_DVFS_ADR1] = 0xf0,
1015 [PWRAP_DVFS_WDATA1] = 0xf4,
1016 [PWRAP_DVFS_ADR2] = 0xf8,
1017 [PWRAP_DVFS_WDATA2] = 0xfc,
1018 [PWRAP_DVFS_ADR3] = 0x100,
1019 [PWRAP_DVFS_WDATA3] = 0x104,
1020 [PWRAP_DVFS_ADR4] = 0x108,
1021 [PWRAP_DVFS_WDATA4] = 0x10c,
1022 [PWRAP_DVFS_ADR5] = 0x110,
1023 [PWRAP_DVFS_WDATA5] = 0x114,
1024 [PWRAP_DVFS_ADR6] = 0x118,
1025 [PWRAP_DVFS_WDATA6] = 0x11c,
1026 [PWRAP_DVFS_ADR7] = 0x120,
1027 [PWRAP_DVFS_WDATA7] = 0x124,
1028 [PWRAP_SPMINF_STA] = 0x128,
1029 [PWRAP_CIPHER_KEY_SEL] = 0x12c,
1030 [PWRAP_CIPHER_IV_SEL] = 0x130,
1031 [PWRAP_CIPHER_EN] = 0x134,
1032 [PWRAP_CIPHER_RDY] = 0x138,
1033 [PWRAP_CIPHER_MODE] = 0x13c,
1034 [PWRAP_CIPHER_SWRST] = 0x140,
1035 [PWRAP_DCM_EN] = 0x144,
1036 [PWRAP_DCM_DBC_PRD] = 0x148,
1037 };
1038
1039 static const int mt8183_regs[] = {
1040 [PWRAP_MUX_SEL] = 0x0,
1041 [PWRAP_WRAP_EN] = 0x4,
1042 [PWRAP_DIO_EN] = 0x8,
1043 [PWRAP_SI_SAMPLE_CTRL] = 0xC,
1044 [PWRAP_RDDMY] = 0x14,
1045 [PWRAP_CSHEXT_WRITE] = 0x18,
1046 [PWRAP_CSHEXT_READ] = 0x1C,
1047 [PWRAP_CSLEXT_WRITE] = 0x20,
1048 [PWRAP_CSLEXT_READ] = 0x24,
1049 [PWRAP_EXT_CK_WRITE] = 0x28,
1050 [PWRAP_STAUPD_CTRL] = 0x30,
1051 [PWRAP_STAUPD_GRPEN] = 0x34,
1052 [PWRAP_EINT_STA0_ADR] = 0x38,
1053 [PWRAP_HARB_HPRIO] = 0x5C,
1054 [PWRAP_HIPRIO_ARB_EN] = 0x60,
1055 [PWRAP_MAN_EN] = 0x70,
1056 [PWRAP_MAN_CMD] = 0x74,
1057 [PWRAP_WACS0_EN] = 0x80,
1058 [PWRAP_INIT_DONE0] = 0x84,
1059 [PWRAP_WACS1_EN] = 0x88,
1060 [PWRAP_INIT_DONE1] = 0x8C,
1061 [PWRAP_WACS2_EN] = 0x90,
1062 [PWRAP_INIT_DONE2] = 0x94,
1063 [PWRAP_WACS_P2P_EN] = 0xA0,
1064 [PWRAP_INIT_DONE_P2P] = 0xA4,
1065 [PWRAP_WACS_MD32_EN] = 0xA8,
1066 [PWRAP_INIT_DONE_MD32] = 0xAC,
1067 [PWRAP_INT_EN] = 0xB0,
1068 [PWRAP_INT_FLG] = 0xB8,
1069 [PWRAP_INT_CLR] = 0xBC,
1070 [PWRAP_INT1_EN] = 0xC0,
1071 [PWRAP_INT1_FLG] = 0xC8,
1072 [PWRAP_INT1_CLR] = 0xCC,
1073 [PWRAP_SIG_ADR] = 0xD0,
1074 [PWRAP_CRC_EN] = 0xE0,
1075 [PWRAP_TIMER_EN] = 0xE4,
1076 [PWRAP_WDT_UNIT] = 0xEC,
1077 [PWRAP_WDT_SRC_EN] = 0xF0,
1078 [PWRAP_WDT_SRC_EN_1] = 0xF4,
1079 [PWRAP_INT_GPS_AUXADC_CMD_ADDR] = 0x1DC,
1080 [PWRAP_INT_GPS_AUXADC_CMD] = 0x1E0,
1081 [PWRAP_INT_GPS_AUXADC_RDATA_ADDR] = 0x1E4,
1082 [PWRAP_EXT_GPS_AUXADC_RDATA_ADDR] = 0x1E8,
1083 [PWRAP_GPSINF_0_STA] = 0x1EC,
1084 [PWRAP_GPSINF_1_STA] = 0x1F0,
1085 [PWRAP_WACS2_CMD] = 0xC20,
1086 [PWRAP_WACS2_RDATA] = 0xC24,
1087 [PWRAP_WACS2_VLDCLR] = 0xC28,
1088 };
1089
1090 static const int mt8195_regs[] = {
1091 [PWRAP_INIT_DONE2] = 0x0,
1092 [PWRAP_STAUPD_CTRL] = 0x4C,
1093 [PWRAP_TIMER_EN] = 0x3E4,
1094 [PWRAP_INT_EN] = 0x420,
1095 [PWRAP_INT_FLG] = 0x428,
1096 [PWRAP_INT_CLR] = 0x42C,
1097 [PWRAP_INT1_EN] = 0x450,
1098 [PWRAP_INT1_FLG] = 0x458,
1099 [PWRAP_INT1_CLR] = 0x45C,
1100 [PWRAP_WACS2_CMD] = 0x880,
1101 [PWRAP_SWINF_2_WDATA_31_0] = 0x884,
1102 [PWRAP_SWINF_2_RDATA_31_0] = 0x894,
1103 [PWRAP_WACS2_VLDCLR] = 0x8A4,
1104 [PWRAP_WACS2_RDATA] = 0x8A8,
1105 };
1106
1107 static const int mt8365_regs[] = {
1108 [PWRAP_MUX_SEL] = 0x0,
1109 [PWRAP_WRAP_EN] = 0x4,
1110 [PWRAP_DIO_EN] = 0x8,
1111 [PWRAP_CSHEXT_WRITE] = 0x24,
1112 [PWRAP_CSHEXT_READ] = 0x28,
1113 [PWRAP_STAUPD_PRD] = 0x3c,
1114 [PWRAP_STAUPD_GRPEN] = 0x40,
1115 [PWRAP_STAUPD_MAN_TRIG] = 0x58,
1116 [PWRAP_STAUPD_STA] = 0x5c,
1117 [PWRAP_WRAP_STA] = 0x60,
1118 [PWRAP_HARB_INIT] = 0x64,
1119 [PWRAP_HARB_HPRIO] = 0x68,
1120 [PWRAP_HIPRIO_ARB_EN] = 0x6c,
1121 [PWRAP_HARB_STA0] = 0x70,
1122 [PWRAP_HARB_STA1] = 0x74,
1123 [PWRAP_MAN_EN] = 0x7c,
1124 [PWRAP_MAN_CMD] = 0x80,
1125 [PWRAP_MAN_RDATA] = 0x84,
1126 [PWRAP_MAN_VLDCLR] = 0x88,
1127 [PWRAP_WACS0_EN] = 0x8c,
1128 [PWRAP_INIT_DONE0] = 0x90,
1129 [PWRAP_WACS0_CMD] = 0xc00,
1130 [PWRAP_WACS0_RDATA] = 0xc04,
1131 [PWRAP_WACS0_VLDCLR] = 0xc08,
1132 [PWRAP_WACS1_EN] = 0x94,
1133 [PWRAP_INIT_DONE1] = 0x98,
1134 [PWRAP_WACS2_EN] = 0x9c,
1135 [PWRAP_INIT_DONE2] = 0xa0,
1136 [PWRAP_WACS2_CMD] = 0xc20,
1137 [PWRAP_WACS2_RDATA] = 0xc24,
1138 [PWRAP_WACS2_VLDCLR] = 0xc28,
1139 [PWRAP_INT_EN] = 0xb4,
1140 [PWRAP_INT_FLG_RAW] = 0xb8,
1141 [PWRAP_INT_FLG] = 0xbc,
1142 [PWRAP_INT_CLR] = 0xc0,
1143 [PWRAP_SIG_ADR] = 0xd4,
1144 [PWRAP_SIG_MODE] = 0xd8,
1145 [PWRAP_SIG_VALUE] = 0xdc,
1146 [PWRAP_SIG_ERRVAL] = 0xe0,
1147 [PWRAP_CRC_EN] = 0xe4,
1148 [PWRAP_TIMER_EN] = 0xe8,
1149 [PWRAP_TIMER_STA] = 0xec,
1150 [PWRAP_WDT_UNIT] = 0xf0,
1151 [PWRAP_WDT_SRC_EN] = 0xf4,
1152 [PWRAP_WDT_FLG] = 0xfc,
1153 [PWRAP_DEBUG_INT_SEL] = 0x104,
1154 [PWRAP_CIPHER_KEY_SEL] = 0x1c4,
1155 [PWRAP_CIPHER_IV_SEL] = 0x1c8,
1156 [PWRAP_CIPHER_RDY] = 0x1d0,
1157 [PWRAP_CIPHER_MODE] = 0x1d4,
1158 [PWRAP_CIPHER_SWRST] = 0x1d8,
1159 [PWRAP_DCM_EN] = 0x1dc,
1160 [PWRAP_DCM_DBC_PRD] = 0x1e0,
1161 [PWRAP_EINT_STA0_ADR] = 0x44,
1162 [PWRAP_EINT_STA1_ADR] = 0x48,
1163 [PWRAP_INT1_EN] = 0xc4,
1164 [PWRAP_INT1_FLG] = 0xcc,
1165 [PWRAP_INT1_CLR] = 0xd0,
1166 [PWRAP_WDT_SRC_EN_1] = 0xf8,
1167 };
1168
1169 static const int mt8516_regs[] = {
1170 [PWRAP_MUX_SEL] = 0x0,
1171 [PWRAP_WRAP_EN] = 0x4,
1172 [PWRAP_DIO_EN] = 0x8,
1173 [PWRAP_SIDLY] = 0xc,
1174 [PWRAP_RDDMY] = 0x10,
1175 [PWRAP_SI_CK_CON] = 0x14,
1176 [PWRAP_CSHEXT_WRITE] = 0x18,
1177 [PWRAP_CSHEXT_READ] = 0x1c,
1178 [PWRAP_CSLEXT_START] = 0x20,
1179 [PWRAP_CSLEXT_END] = 0x24,
1180 [PWRAP_STAUPD_PRD] = 0x28,
1181 [PWRAP_STAUPD_GRPEN] = 0x2c,
1182 [PWRAP_STAUPD_MAN_TRIG] = 0x40,
1183 [PWRAP_STAUPD_STA] = 0x44,
1184 [PWRAP_WRAP_STA] = 0x48,
1185 [PWRAP_HARB_INIT] = 0x4c,
1186 [PWRAP_HARB_HPRIO] = 0x50,
1187 [PWRAP_HIPRIO_ARB_EN] = 0x54,
1188 [PWRAP_HARB_STA0] = 0x58,
1189 [PWRAP_HARB_STA1] = 0x5c,
1190 [PWRAP_MAN_EN] = 0x60,
1191 [PWRAP_MAN_CMD] = 0x64,
1192 [PWRAP_MAN_RDATA] = 0x68,
1193 [PWRAP_MAN_VLDCLR] = 0x6c,
1194 [PWRAP_WACS0_EN] = 0x70,
1195 [PWRAP_INIT_DONE0] = 0x74,
1196 [PWRAP_WACS0_CMD] = 0x78,
1197 [PWRAP_WACS0_RDATA] = 0x7c,
1198 [PWRAP_WACS0_VLDCLR] = 0x80,
1199 [PWRAP_WACS1_EN] = 0x84,
1200 [PWRAP_INIT_DONE1] = 0x88,
1201 [PWRAP_WACS1_CMD] = 0x8c,
1202 [PWRAP_WACS1_RDATA] = 0x90,
1203 [PWRAP_WACS1_VLDCLR] = 0x94,
1204 [PWRAP_WACS2_EN] = 0x98,
1205 [PWRAP_INIT_DONE2] = 0x9c,
1206 [PWRAP_WACS2_CMD] = 0xa0,
1207 [PWRAP_WACS2_RDATA] = 0xa4,
1208 [PWRAP_WACS2_VLDCLR] = 0xa8,
1209 [PWRAP_INT_EN] = 0xac,
1210 [PWRAP_INT_FLG_RAW] = 0xb0,
1211 [PWRAP_INT_FLG] = 0xb4,
1212 [PWRAP_INT_CLR] = 0xb8,
1213 [PWRAP_SIG_ADR] = 0xbc,
1214 [PWRAP_SIG_MODE] = 0xc0,
1215 [PWRAP_SIG_VALUE] = 0xc4,
1216 [PWRAP_SIG_ERRVAL] = 0xc8,
1217 [PWRAP_CRC_EN] = 0xcc,
1218 [PWRAP_TIMER_EN] = 0xd0,
1219 [PWRAP_TIMER_STA] = 0xd4,
1220 [PWRAP_WDT_UNIT] = 0xd8,
1221 [PWRAP_WDT_SRC_EN] = 0xdc,
1222 [PWRAP_WDT_FLG] = 0xe0,
1223 [PWRAP_DEBUG_INT_SEL] = 0xe4,
1224 [PWRAP_DVFS_ADR0] = 0xe8,
1225 [PWRAP_DVFS_WDATA0] = 0xec,
1226 [PWRAP_DVFS_ADR1] = 0xf0,
1227 [PWRAP_DVFS_WDATA1] = 0xf4,
1228 [PWRAP_DVFS_ADR2] = 0xf8,
1229 [PWRAP_DVFS_WDATA2] = 0xfc,
1230 [PWRAP_DVFS_ADR3] = 0x100,
1231 [PWRAP_DVFS_WDATA3] = 0x104,
1232 [PWRAP_DVFS_ADR4] = 0x108,
1233 [PWRAP_DVFS_WDATA4] = 0x10c,
1234 [PWRAP_DVFS_ADR5] = 0x110,
1235 [PWRAP_DVFS_WDATA5] = 0x114,
1236 [PWRAP_DVFS_ADR6] = 0x118,
1237 [PWRAP_DVFS_WDATA6] = 0x11c,
1238 [PWRAP_DVFS_ADR7] = 0x120,
1239 [PWRAP_DVFS_WDATA7] = 0x124,
1240 [PWRAP_SPMINF_STA] = 0x128,
1241 [PWRAP_CIPHER_KEY_SEL] = 0x12c,
1242 [PWRAP_CIPHER_IV_SEL] = 0x130,
1243 [PWRAP_CIPHER_EN] = 0x134,
1244 [PWRAP_CIPHER_RDY] = 0x138,
1245 [PWRAP_CIPHER_MODE] = 0x13c,
1246 [PWRAP_CIPHER_SWRST] = 0x140,
1247 [PWRAP_DCM_EN] = 0x144,
1248 [PWRAP_DCM_DBC_PRD] = 0x148,
1249 [PWRAP_SW_RST] = 0x168,
1250 [PWRAP_OP_TYPE] = 0x16c,
1251 [PWRAP_MSB_FIRST] = 0x170,
1252 };
1253
1254 static const int mt8186_regs[] = {
1255 [PWRAP_MUX_SEL] = 0x0,
1256 [PWRAP_WRAP_EN] = 0x4,
1257 [PWRAP_DIO_EN] = 0x8,
1258 [PWRAP_RDDMY] = 0x20,
1259 [PWRAP_CSHEXT_WRITE] = 0x24,
1260 [PWRAP_CSHEXT_READ] = 0x28,
1261 [PWRAP_CSLEXT_WRITE] = 0x2C,
1262 [PWRAP_CSLEXT_READ] = 0x30,
1263 [PWRAP_EXT_CK_WRITE] = 0x34,
1264 [PWRAP_STAUPD_CTRL] = 0x3C,
1265 [PWRAP_STAUPD_GRPEN] = 0x40,
1266 [PWRAP_EINT_STA0_ADR] = 0x44,
1267 [PWRAP_EINT_STA1_ADR] = 0x48,
1268 [PWRAP_INT_CLR] = 0xC8,
1269 [PWRAP_INT_FLG] = 0xC4,
1270 [PWRAP_MAN_EN] = 0x7C,
1271 [PWRAP_MAN_CMD] = 0x80,
1272 [PWRAP_WACS0_EN] = 0x8C,
1273 [PWRAP_WACS1_EN] = 0x94,
1274 [PWRAP_WACS2_EN] = 0x9C,
1275 [PWRAP_INIT_DONE0] = 0x90,
1276 [PWRAP_INIT_DONE1] = 0x98,
1277 [PWRAP_INIT_DONE2] = 0xA0,
1278 [PWRAP_INT_EN] = 0xBC,
1279 [PWRAP_INT1_EN] = 0xCC,
1280 [PWRAP_INT1_FLG] = 0xD4,
1281 [PWRAP_INT1_CLR] = 0xD8,
1282 [PWRAP_TIMER_EN] = 0xF0,
1283 [PWRAP_WDT_UNIT] = 0xF8,
1284 [PWRAP_WDT_SRC_EN] = 0xFC,
1285 [PWRAP_WDT_SRC_EN_1] = 0x100,
1286 [PWRAP_WDT_FLG] = 0x104,
1287 [PWRAP_SPMINF_STA] = 0x1B4,
1288 [PWRAP_DCM_EN] = 0x1EC,
1289 [PWRAP_DCM_DBC_PRD] = 0x1F0,
1290 [PWRAP_GPSINF_0_STA] = 0x204,
1291 [PWRAP_GPSINF_1_STA] = 0x208,
1292 [PWRAP_WACS0_CMD] = 0xC00,
1293 [PWRAP_WACS0_RDATA] = 0xC04,
1294 [PWRAP_WACS0_VLDCLR] = 0xC08,
1295 [PWRAP_WACS1_CMD] = 0xC10,
1296 [PWRAP_WACS1_RDATA] = 0xC14,
1297 [PWRAP_WACS1_VLDCLR] = 0xC18,
1298 [PWRAP_WACS2_CMD] = 0xC20,
1299 [PWRAP_WACS2_RDATA] = 0xC24,
1300 [PWRAP_WACS2_VLDCLR] = 0xC28,
1301 };
1302
1303 enum pmic_type {
1304 PMIC_MT6323,
1305 PMIC_MT6331,
1306 PMIC_MT6332,
1307 PMIC_MT6351,
1308 PMIC_MT6357,
1309 PMIC_MT6358,
1310 PMIC_MT6359,
1311 PMIC_MT6380,
1312 PMIC_MT6397,
1313 };
1314
1315 enum pwrap_type {
1316 PWRAP_MT2701,
1317 PWRAP_MT6765,
1318 PWRAP_MT6779,
1319 PWRAP_MT6795,
1320 PWRAP_MT6797,
1321 PWRAP_MT6873,
1322 PWRAP_MT7622,
1323 PWRAP_MT8135,
1324 PWRAP_MT8173,
1325 PWRAP_MT8183,
1326 PWRAP_MT8186,
1327 PWRAP_MT8195,
1328 PWRAP_MT8365,
1329 PWRAP_MT8516,
1330 };
1331
1332 struct pmic_wrapper;
1333
1334 struct pwrap_slv_regops {
1335 const struct regmap_config *regmap;
1336 /*
1337 * pwrap operations are highly associated with the PMIC types,
1338 * so the pointers added increases flexibility allowing determination
1339 * which type is used by the detection through device tree.
1340 */
1341 int (*pwrap_read)(struct pmic_wrapper *wrp, u32 adr, u32 *rdata);
1342 int (*pwrap_write)(struct pmic_wrapper *wrp, u32 adr, u32 wdata);
1343 };
1344
1345 /**
1346 * struct pwrap_slv_type - PMIC device wrapper definitions
1347 * @dew_regs: Device Wrapper (DeW) register offsets
1348 * @type: PMIC Type (model)
1349 * @comp_dew_regs: Device Wrapper (DeW) register offsets for companion device
1350 * @comp_type: Companion PMIC Type (model)
1351 * @regops: Register R/W ops
1352 * @caps: Capability flags for the target device
1353 */
1354 struct pwrap_slv_type {
1355 const u32 *dew_regs;
1356 enum pmic_type type;
1357 const u32 *comp_dew_regs;
1358 enum pmic_type comp_type;
1359 const struct pwrap_slv_regops *regops;
1360 u32 caps;
1361 };
1362
1363 struct pmic_wrapper {
1364 struct device *dev;
1365 void __iomem *base;
1366 struct regmap *regmap;
1367 const struct pmic_wrapper_type *master;
1368 const struct pwrap_slv_type *slave;
1369 struct reset_control *rstc;
1370
1371 struct reset_control *rstc_bridge;
1372 void __iomem *bridge_base;
1373 };
1374
1375 struct pmic_wrapper_type {
1376 const int *regs;
1377 enum pwrap_type type;
1378 u32 arb_en_all;
1379 u32 int_en_all;
1380 u32 int1_en_all;
1381 u32 spi_w;
1382 u32 wdt_src;
1383 /* Flags indicating the capability for the target pwrap */
1384 u32 caps;
1385 int (*init_reg_clock)(struct pmic_wrapper *wrp);
1386 int (*init_soc_specific)(struct pmic_wrapper *wrp);
1387 };
1388
pwrap_readl(struct pmic_wrapper * wrp,enum pwrap_regs reg)1389 static u32 pwrap_readl(struct pmic_wrapper *wrp, enum pwrap_regs reg)
1390 {
1391 return readl(wrp->base + wrp->master->regs[reg]);
1392 }
1393
pwrap_writel(struct pmic_wrapper * wrp,u32 val,enum pwrap_regs reg)1394 static void pwrap_writel(struct pmic_wrapper *wrp, u32 val, enum pwrap_regs reg)
1395 {
1396 writel(val, wrp->base + wrp->master->regs[reg]);
1397 }
1398
pwrap_get_fsm_state(struct pmic_wrapper * wrp)1399 static u32 pwrap_get_fsm_state(struct pmic_wrapper *wrp)
1400 {
1401 u32 val;
1402
1403 val = pwrap_readl(wrp, PWRAP_WACS2_RDATA);
1404 if (HAS_CAP(wrp->master->caps, PWRAP_CAP_ARB))
1405 return PWRAP_GET_WACS_ARB_FSM(val);
1406 else
1407 return PWRAP_GET_WACS_FSM(val);
1408 }
1409
pwrap_is_fsm_idle(struct pmic_wrapper * wrp)1410 static bool pwrap_is_fsm_idle(struct pmic_wrapper *wrp)
1411 {
1412 return pwrap_get_fsm_state(wrp) == PWRAP_WACS_FSM_IDLE;
1413 }
1414
pwrap_is_fsm_vldclr(struct pmic_wrapper * wrp)1415 static bool pwrap_is_fsm_vldclr(struct pmic_wrapper *wrp)
1416 {
1417 return pwrap_get_fsm_state(wrp) == PWRAP_WACS_FSM_WFVLDCLR;
1418 }
1419
1420 /*
1421 * Timeout issue sometimes caused by the last read command
1422 * failed because pmic wrap could not got the FSM_VLDCLR
1423 * in time after finishing WACS2_CMD. It made state machine
1424 * still on FSM_VLDCLR and timeout next time.
1425 * Check the status of FSM and clear the vldclr to recovery the
1426 * error.
1427 */
pwrap_leave_fsm_vldclr(struct pmic_wrapper * wrp)1428 static inline void pwrap_leave_fsm_vldclr(struct pmic_wrapper *wrp)
1429 {
1430 if (pwrap_is_fsm_vldclr(wrp))
1431 pwrap_writel(wrp, 1, PWRAP_WACS2_VLDCLR);
1432 }
1433
pwrap_is_sync_idle(struct pmic_wrapper * wrp)1434 static bool pwrap_is_sync_idle(struct pmic_wrapper *wrp)
1435 {
1436 return pwrap_readl(wrp, PWRAP_WACS2_RDATA) & PWRAP_STATE_SYNC_IDLE0;
1437 }
1438
pwrap_is_fsm_idle_and_sync_idle(struct pmic_wrapper * wrp)1439 static bool pwrap_is_fsm_idle_and_sync_idle(struct pmic_wrapper *wrp)
1440 {
1441 u32 val = pwrap_readl(wrp, PWRAP_WACS2_RDATA);
1442
1443 return (PWRAP_GET_WACS_FSM(val) == PWRAP_WACS_FSM_IDLE) &&
1444 (val & PWRAP_STATE_SYNC_IDLE0);
1445 }
1446
pwrap_read16(struct pmic_wrapper * wrp,u32 adr,u32 * rdata)1447 static int pwrap_read16(struct pmic_wrapper *wrp, u32 adr, u32 *rdata)
1448 {
1449 bool tmp;
1450 int ret;
1451 u32 val;
1452
1453 ret = readx_poll_timeout(pwrap_is_fsm_idle, wrp, tmp, tmp,
1454 PWRAP_POLL_DELAY_US, PWRAP_POLL_TIMEOUT_US);
1455 if (ret) {
1456 pwrap_leave_fsm_vldclr(wrp);
1457 return ret;
1458 }
1459
1460 if (HAS_CAP(wrp->master->caps, PWRAP_CAP_ARB))
1461 val = adr;
1462 else
1463 val = (adr >> 1) << 16;
1464 pwrap_writel(wrp, val, PWRAP_WACS2_CMD);
1465
1466 ret = readx_poll_timeout(pwrap_is_fsm_vldclr, wrp, tmp, tmp,
1467 PWRAP_POLL_DELAY_US, PWRAP_POLL_TIMEOUT_US);
1468 if (ret)
1469 return ret;
1470
1471 if (HAS_CAP(wrp->master->caps, PWRAP_CAP_ARB))
1472 val = pwrap_readl(wrp, PWRAP_SWINF_2_RDATA_31_0);
1473 else
1474 val = pwrap_readl(wrp, PWRAP_WACS2_RDATA);
1475 *rdata = PWRAP_GET_WACS_RDATA(val);
1476
1477 pwrap_writel(wrp, 1, PWRAP_WACS2_VLDCLR);
1478
1479 return 0;
1480 }
1481
pwrap_read32(struct pmic_wrapper * wrp,u32 adr,u32 * rdata)1482 static int pwrap_read32(struct pmic_wrapper *wrp, u32 adr, u32 *rdata)
1483 {
1484 bool tmp;
1485 int ret, msb;
1486
1487 *rdata = 0;
1488 for (msb = 0; msb < 2; msb++) {
1489 ret = readx_poll_timeout(pwrap_is_fsm_idle, wrp, tmp, tmp,
1490 PWRAP_POLL_DELAY_US, PWRAP_POLL_TIMEOUT_US);
1491
1492 if (ret) {
1493 pwrap_leave_fsm_vldclr(wrp);
1494 return ret;
1495 }
1496
1497 pwrap_writel(wrp, ((msb << 30) | (adr << 16)),
1498 PWRAP_WACS2_CMD);
1499
1500 ret = readx_poll_timeout(pwrap_is_fsm_vldclr, wrp, tmp, tmp,
1501 PWRAP_POLL_DELAY_US, PWRAP_POLL_TIMEOUT_US);
1502 if (ret)
1503 return ret;
1504
1505 *rdata += (PWRAP_GET_WACS_RDATA(pwrap_readl(wrp,
1506 PWRAP_WACS2_RDATA)) << (16 * msb));
1507
1508 pwrap_writel(wrp, 1, PWRAP_WACS2_VLDCLR);
1509 }
1510
1511 return 0;
1512 }
1513
pwrap_read(struct pmic_wrapper * wrp,u32 adr,u32 * rdata)1514 static int pwrap_read(struct pmic_wrapper *wrp, u32 adr, u32 *rdata)
1515 {
1516 return wrp->slave->regops->pwrap_read(wrp, adr, rdata);
1517 }
1518
pwrap_write16(struct pmic_wrapper * wrp,u32 adr,u32 wdata)1519 static int pwrap_write16(struct pmic_wrapper *wrp, u32 adr, u32 wdata)
1520 {
1521 bool tmp;
1522 int ret;
1523
1524 ret = readx_poll_timeout(pwrap_is_fsm_idle, wrp, tmp, tmp,
1525 PWRAP_POLL_DELAY_US, PWRAP_POLL_TIMEOUT_US);
1526 if (ret) {
1527 pwrap_leave_fsm_vldclr(wrp);
1528 return ret;
1529 }
1530
1531 if (HAS_CAP(wrp->master->caps, PWRAP_CAP_ARB)) {
1532 pwrap_writel(wrp, wdata, PWRAP_SWINF_2_WDATA_31_0);
1533 pwrap_writel(wrp, BIT(29) | adr, PWRAP_WACS2_CMD);
1534 } else {
1535 pwrap_writel(wrp, BIT(31) | ((adr >> 1) << 16) | wdata,
1536 PWRAP_WACS2_CMD);
1537 }
1538
1539 return 0;
1540 }
1541
pwrap_write32(struct pmic_wrapper * wrp,u32 adr,u32 wdata)1542 static int pwrap_write32(struct pmic_wrapper *wrp, u32 adr, u32 wdata)
1543 {
1544 bool tmp;
1545 int ret, msb, rdata;
1546
1547 for (msb = 0; msb < 2; msb++) {
1548 ret = readx_poll_timeout(pwrap_is_fsm_idle, wrp, tmp, tmp,
1549 PWRAP_POLL_DELAY_US, PWRAP_POLL_TIMEOUT_US);
1550 if (ret) {
1551 pwrap_leave_fsm_vldclr(wrp);
1552 return ret;
1553 }
1554
1555 pwrap_writel(wrp, (1 << 31) | (msb << 30) | (adr << 16) |
1556 ((wdata >> (msb * 16)) & 0xffff),
1557 PWRAP_WACS2_CMD);
1558
1559 /*
1560 * The pwrap_read operation is the requirement of hardware used
1561 * for the synchronization between two successive 16-bit
1562 * pwrap_writel operations composing one 32-bit bus writing.
1563 * Otherwise, we'll find the result fails on the lower 16-bit
1564 * pwrap writing.
1565 */
1566 if (!msb)
1567 pwrap_read(wrp, adr, &rdata);
1568 }
1569
1570 return 0;
1571 }
1572
pwrap_write(struct pmic_wrapper * wrp,u32 adr,u32 wdata)1573 static int pwrap_write(struct pmic_wrapper *wrp, u32 adr, u32 wdata)
1574 {
1575 return wrp->slave->regops->pwrap_write(wrp, adr, wdata);
1576 }
1577
pwrap_regmap_read(void * context,u32 adr,u32 * rdata)1578 static int pwrap_regmap_read(void *context, u32 adr, u32 *rdata)
1579 {
1580 return pwrap_read(context, adr, rdata);
1581 }
1582
pwrap_regmap_write(void * context,u32 adr,u32 wdata)1583 static int pwrap_regmap_write(void *context, u32 adr, u32 wdata)
1584 {
1585 return pwrap_write(context, adr, wdata);
1586 }
1587
pwrap_pmic_read_test(struct pmic_wrapper * wrp,const u32 * dew_regs,u16 read_test_val)1588 static bool pwrap_pmic_read_test(struct pmic_wrapper *wrp, const u32 *dew_regs,
1589 u16 read_test_val)
1590 {
1591 bool is_success;
1592 u32 rdata;
1593
1594 pwrap_read(wrp, dew_regs[PWRAP_DEW_READ_TEST], &rdata);
1595 is_success = ((rdata & U16_MAX) == read_test_val);
1596
1597 return is_success;
1598 }
1599
pwrap_reset_spislave(struct pmic_wrapper * wrp)1600 static int pwrap_reset_spislave(struct pmic_wrapper *wrp)
1601 {
1602 bool tmp;
1603 int ret, i;
1604
1605 pwrap_writel(wrp, 0, PWRAP_HIPRIO_ARB_EN);
1606 pwrap_writel(wrp, 0, PWRAP_WRAP_EN);
1607 pwrap_writel(wrp, 1, PWRAP_MUX_SEL);
1608 pwrap_writel(wrp, 1, PWRAP_MAN_EN);
1609 pwrap_writel(wrp, 0, PWRAP_DIO_EN);
1610
1611 pwrap_writel(wrp, wrp->master->spi_w | PWRAP_MAN_CMD_OP_CSL,
1612 PWRAP_MAN_CMD);
1613 pwrap_writel(wrp, wrp->master->spi_w | PWRAP_MAN_CMD_OP_OUTS,
1614 PWRAP_MAN_CMD);
1615 pwrap_writel(wrp, wrp->master->spi_w | PWRAP_MAN_CMD_OP_CSH,
1616 PWRAP_MAN_CMD);
1617
1618 for (i = 0; i < 4; i++)
1619 pwrap_writel(wrp, wrp->master->spi_w | PWRAP_MAN_CMD_OP_OUTS,
1620 PWRAP_MAN_CMD);
1621
1622 ret = readx_poll_timeout(pwrap_is_sync_idle, wrp, tmp, tmp,
1623 PWRAP_POLL_DELAY_US, PWRAP_POLL_TIMEOUT_US);
1624 if (ret) {
1625 dev_err(wrp->dev, "%s fail, ret=%d\n", __func__, ret);
1626 return ret;
1627 }
1628
1629 pwrap_writel(wrp, 0, PWRAP_MAN_EN);
1630 pwrap_writel(wrp, 0, PWRAP_MUX_SEL);
1631
1632 return 0;
1633 }
1634
1635 /*
1636 * pwrap_init_sidly - configure serial input delay
1637 *
1638 * This configures the serial input delay. We can configure 0, 2, 4 or 6ns
1639 * delay. Do a read test with all possible values and chose the best delay.
1640 */
pwrap_init_sidly(struct pmic_wrapper * wrp)1641 static int pwrap_init_sidly(struct pmic_wrapper *wrp)
1642 {
1643 u32 i;
1644 u32 pass = 0;
1645 bool read_ok;
1646 signed char dly[16] = {
1647 -1, 0, 1, 0, 2, -1, 1, 1, 3, -1, -1, -1, 3, -1, 2, 1
1648 };
1649
1650 for (i = 0; i < 4; i++) {
1651 pwrap_writel(wrp, i, PWRAP_SIDLY);
1652 read_ok = pwrap_pmic_read_test(wrp, wrp->slave->dew_regs,
1653 PWRAP_DEW_READ_TEST_VAL);
1654 if (read_ok) {
1655 dev_dbg(wrp->dev, "[Read Test] pass, SIDLY=%x\n", i);
1656 pass |= 1 << i;
1657 }
1658 }
1659
1660 if (dly[pass] < 0) {
1661 dev_err(wrp->dev, "sidly pass range 0x%x not continuous\n",
1662 pass);
1663 return -EIO;
1664 }
1665
1666 pwrap_writel(wrp, dly[pass], PWRAP_SIDLY);
1667
1668 return 0;
1669 }
1670
pwrap_init_dual_io(struct pmic_wrapper * wrp)1671 static int pwrap_init_dual_io(struct pmic_wrapper *wrp)
1672 {
1673 int ret;
1674 bool read_ok, tmp;
1675 bool comp_read_ok = true;
1676
1677 /* Enable dual IO mode */
1678 pwrap_write(wrp, wrp->slave->dew_regs[PWRAP_DEW_DIO_EN], 1);
1679 if (wrp->slave->comp_dew_regs)
1680 pwrap_write(wrp, wrp->slave->comp_dew_regs[PWRAP_DEW_DIO_EN], 1);
1681
1682 /* Check IDLE & INIT_DONE in advance */
1683 ret = readx_poll_timeout(pwrap_is_fsm_idle_and_sync_idle, wrp, tmp, tmp,
1684 PWRAP_POLL_DELAY_US, PWRAP_POLL_TIMEOUT_US);
1685 if (ret) {
1686 dev_err(wrp->dev, "%s fail, ret=%d\n", __func__, ret);
1687 return ret;
1688 }
1689
1690 pwrap_writel(wrp, 1, PWRAP_DIO_EN);
1691
1692 /* Read Test */
1693 read_ok = pwrap_pmic_read_test(wrp, wrp->slave->dew_regs, PWRAP_DEW_READ_TEST_VAL);
1694 if (wrp->slave->comp_dew_regs)
1695 comp_read_ok = pwrap_pmic_read_test(wrp, wrp->slave->comp_dew_regs,
1696 PWRAP_DEW_COMP_READ_TEST_VAL);
1697 if (!read_ok || !comp_read_ok) {
1698 dev_err(wrp->dev, "Read failed on DIO mode. Main PMIC %s%s\n",
1699 !read_ok ? "fail" : "success",
1700 wrp->slave->comp_dew_regs && !comp_read_ok ?
1701 ", Companion PMIC fail" : "");
1702 return -EFAULT;
1703 }
1704
1705 return 0;
1706 }
1707
1708 /*
1709 * pwrap_init_chip_select_ext is used to configure CS extension time for each
1710 * phase during data transactions on the pwrap bus.
1711 */
pwrap_init_chip_select_ext(struct pmic_wrapper * wrp,u8 hext_write,u8 hext_read,u8 lext_start,u8 lext_end)1712 static void pwrap_init_chip_select_ext(struct pmic_wrapper *wrp, u8 hext_write,
1713 u8 hext_read, u8 lext_start,
1714 u8 lext_end)
1715 {
1716 /*
1717 * After finishing a write and read transaction, extends CS high time
1718 * to be at least xT of BUS CLK as hext_write and hext_read specifies
1719 * respectively.
1720 */
1721 pwrap_writel(wrp, hext_write, PWRAP_CSHEXT_WRITE);
1722 pwrap_writel(wrp, hext_read, PWRAP_CSHEXT_READ);
1723
1724 /*
1725 * Extends CS low time after CSL and before CSH command to be at
1726 * least xT of BUS CLK as lext_start and lext_end specifies
1727 * respectively.
1728 */
1729 pwrap_writel(wrp, lext_start, PWRAP_CSLEXT_START);
1730 pwrap_writel(wrp, lext_end, PWRAP_CSLEXT_END);
1731 }
1732
pwrap_common_init_reg_clock(struct pmic_wrapper * wrp)1733 static int pwrap_common_init_reg_clock(struct pmic_wrapper *wrp)
1734 {
1735 switch (wrp->master->type) {
1736 case PWRAP_MT6795:
1737 if (wrp->slave->type == PMIC_MT6331) {
1738 const u32 *dew_regs = wrp->slave->dew_regs;
1739
1740 pwrap_write(wrp, dew_regs[PWRAP_DEW_RDDMY_NO], 0x8);
1741
1742 if (wrp->slave->comp_type == PMIC_MT6332) {
1743 dew_regs = wrp->slave->comp_dew_regs;
1744 pwrap_write(wrp, dew_regs[PWRAP_DEW_RDDMY_NO], 0x8);
1745 }
1746 }
1747 pwrap_writel(wrp, 0x88, PWRAP_RDDMY);
1748 pwrap_init_chip_select_ext(wrp, 15, 15, 15, 15);
1749 break;
1750 case PWRAP_MT8173:
1751 pwrap_init_chip_select_ext(wrp, 0, 4, 2, 2);
1752 break;
1753 case PWRAP_MT8135:
1754 pwrap_writel(wrp, 0x4, PWRAP_CSHEXT);
1755 pwrap_init_chip_select_ext(wrp, 0, 4, 0, 0);
1756 break;
1757 default:
1758 break;
1759 }
1760
1761 return 0;
1762 }
1763
pwrap_mt2701_init_reg_clock(struct pmic_wrapper * wrp)1764 static int pwrap_mt2701_init_reg_clock(struct pmic_wrapper *wrp)
1765 {
1766 switch (wrp->slave->type) {
1767 case PMIC_MT6397:
1768 pwrap_writel(wrp, 0xc, PWRAP_RDDMY);
1769 pwrap_init_chip_select_ext(wrp, 4, 0, 2, 2);
1770 break;
1771
1772 case PMIC_MT6323:
1773 pwrap_writel(wrp, 0x8, PWRAP_RDDMY);
1774 pwrap_write(wrp, wrp->slave->dew_regs[PWRAP_DEW_RDDMY_NO],
1775 0x8);
1776 pwrap_init_chip_select_ext(wrp, 5, 0, 2, 2);
1777 break;
1778 default:
1779 break;
1780 }
1781
1782 return 0;
1783 }
1784
pwrap_is_cipher_ready(struct pmic_wrapper * wrp)1785 static bool pwrap_is_cipher_ready(struct pmic_wrapper *wrp)
1786 {
1787 return pwrap_readl(wrp, PWRAP_CIPHER_RDY) & 1;
1788 }
1789
__pwrap_is_pmic_cipher_ready(struct pmic_wrapper * wrp,const u32 * dew_regs)1790 static bool __pwrap_is_pmic_cipher_ready(struct pmic_wrapper *wrp, const u32 *dew_regs)
1791 {
1792 u32 rdata;
1793 int ret;
1794
1795 ret = pwrap_read(wrp, dew_regs[PWRAP_DEW_CIPHER_RDY], &rdata);
1796 if (ret)
1797 return false;
1798
1799 return rdata == 1;
1800 }
1801
1802
pwrap_is_pmic_cipher_ready(struct pmic_wrapper * wrp)1803 static bool pwrap_is_pmic_cipher_ready(struct pmic_wrapper *wrp)
1804 {
1805 bool ret = __pwrap_is_pmic_cipher_ready(wrp, wrp->slave->dew_regs);
1806
1807 if (!ret)
1808 return ret;
1809
1810 /* If there's any companion, wait for it to be ready too */
1811 if (wrp->slave->comp_dew_regs)
1812 ret = __pwrap_is_pmic_cipher_ready(wrp, wrp->slave->comp_dew_regs);
1813
1814 return ret;
1815 }
1816
pwrap_config_cipher(struct pmic_wrapper * wrp,const u32 * dew_regs)1817 static void pwrap_config_cipher(struct pmic_wrapper *wrp, const u32 *dew_regs)
1818 {
1819 pwrap_write(wrp, dew_regs[PWRAP_DEW_CIPHER_SWRST], 0x1);
1820 pwrap_write(wrp, dew_regs[PWRAP_DEW_CIPHER_SWRST], 0x0);
1821 pwrap_write(wrp, dew_regs[PWRAP_DEW_CIPHER_KEY_SEL], 0x1);
1822 pwrap_write(wrp, dew_regs[PWRAP_DEW_CIPHER_IV_SEL], 0x2);
1823 }
1824
pwrap_init_cipher(struct pmic_wrapper * wrp)1825 static int pwrap_init_cipher(struct pmic_wrapper *wrp)
1826 {
1827 int ret;
1828 bool tmp;
1829 u32 rdata = 0;
1830
1831 pwrap_writel(wrp, 0x1, PWRAP_CIPHER_SWRST);
1832 pwrap_writel(wrp, 0x0, PWRAP_CIPHER_SWRST);
1833 pwrap_writel(wrp, 0x1, PWRAP_CIPHER_KEY_SEL);
1834 pwrap_writel(wrp, 0x2, PWRAP_CIPHER_IV_SEL);
1835
1836 switch (wrp->master->type) {
1837 case PWRAP_MT8135:
1838 pwrap_writel(wrp, 1, PWRAP_CIPHER_LOAD);
1839 pwrap_writel(wrp, 1, PWRAP_CIPHER_START);
1840 break;
1841 case PWRAP_MT2701:
1842 case PWRAP_MT6765:
1843 case PWRAP_MT6779:
1844 case PWRAP_MT6795:
1845 case PWRAP_MT6797:
1846 case PWRAP_MT8173:
1847 case PWRAP_MT8186:
1848 case PWRAP_MT8365:
1849 case PWRAP_MT8516:
1850 pwrap_writel(wrp, 1, PWRAP_CIPHER_EN);
1851 break;
1852 case PWRAP_MT7622:
1853 pwrap_writel(wrp, 0, PWRAP_CIPHER_EN);
1854 break;
1855 case PWRAP_MT6873:
1856 case PWRAP_MT8183:
1857 case PWRAP_MT8195:
1858 break;
1859 }
1860
1861 /* Config cipher mode @PMIC */
1862 pwrap_config_cipher(wrp, wrp->slave->dew_regs);
1863
1864 /* If there is any companion PMIC, configure cipher mode there too */
1865 if (wrp->slave->comp_type > 0)
1866 pwrap_config_cipher(wrp, wrp->slave->comp_dew_regs);
1867
1868 switch (wrp->slave->type) {
1869 case PMIC_MT6397:
1870 pwrap_write(wrp, wrp->slave->dew_regs[PWRAP_DEW_CIPHER_LOAD],
1871 0x1);
1872 pwrap_write(wrp, wrp->slave->dew_regs[PWRAP_DEW_CIPHER_START],
1873 0x1);
1874 break;
1875 case PMIC_MT6323:
1876 case PMIC_MT6351:
1877 case PMIC_MT6357:
1878 pwrap_write(wrp, wrp->slave->dew_regs[PWRAP_DEW_CIPHER_EN],
1879 0x1);
1880 break;
1881 default:
1882 break;
1883 }
1884
1885 /* wait for cipher data ready@AP */
1886 ret = readx_poll_timeout(pwrap_is_cipher_ready, wrp, tmp, tmp,
1887 PWRAP_POLL_DELAY_US, PWRAP_POLL_TIMEOUT_US);
1888 if (ret) {
1889 dev_err(wrp->dev, "cipher data ready@AP fail, ret=%d\n", ret);
1890 return ret;
1891 }
1892
1893 /* wait for cipher data ready@PMIC */
1894 ret = readx_poll_timeout(pwrap_is_pmic_cipher_ready, wrp, tmp, tmp,
1895 PWRAP_POLL_DELAY_US, PWRAP_POLL_TIMEOUT_US);
1896 if (ret) {
1897 dev_err(wrp->dev,
1898 "timeout waiting for cipher data ready@PMIC\n");
1899 return ret;
1900 }
1901
1902 /* wait for cipher mode idle */
1903 pwrap_write(wrp, wrp->slave->dew_regs[PWRAP_DEW_CIPHER_MODE], 0x1);
1904 ret = readx_poll_timeout(pwrap_is_fsm_idle_and_sync_idle, wrp, tmp, tmp,
1905 PWRAP_POLL_DELAY_US, PWRAP_POLL_TIMEOUT_US);
1906 if (ret) {
1907 dev_err(wrp->dev, "cipher mode idle fail, ret=%d\n", ret);
1908 return ret;
1909 }
1910
1911 pwrap_writel(wrp, 1, PWRAP_CIPHER_MODE);
1912
1913 /* Write Test */
1914 if (pwrap_write(wrp, wrp->slave->dew_regs[PWRAP_DEW_WRITE_TEST],
1915 PWRAP_DEW_WRITE_TEST_VAL) ||
1916 pwrap_read(wrp, wrp->slave->dew_regs[PWRAP_DEW_WRITE_TEST],
1917 &rdata) ||
1918 (rdata != PWRAP_DEW_WRITE_TEST_VAL)) {
1919 dev_err(wrp->dev, "rdata=0x%04X\n", rdata);
1920 return -EFAULT;
1921 }
1922
1923 return 0;
1924 }
1925
pwrap_init_security(struct pmic_wrapper * wrp)1926 static int pwrap_init_security(struct pmic_wrapper *wrp)
1927 {
1928 u32 crc_val;
1929 int ret;
1930
1931 /* Enable encryption */
1932 ret = pwrap_init_cipher(wrp);
1933 if (ret)
1934 return ret;
1935
1936 /* Signature checking - using CRC */
1937 ret = pwrap_write(wrp, wrp->slave->dew_regs[PWRAP_DEW_CRC_EN], 0x1);
1938 if (ret == 0 && wrp->slave->comp_dew_regs)
1939 ret = pwrap_write(wrp, wrp->slave->comp_dew_regs[PWRAP_DEW_CRC_EN], 0x1);
1940
1941 pwrap_writel(wrp, 0x1, PWRAP_CRC_EN);
1942 pwrap_writel(wrp, 0x0, PWRAP_SIG_MODE);
1943
1944 /* CRC value */
1945 crc_val = wrp->slave->dew_regs[PWRAP_DEW_CRC_VAL];
1946 if (wrp->slave->comp_dew_regs)
1947 crc_val |= wrp->slave->comp_dew_regs[PWRAP_DEW_CRC_VAL] << 16;
1948
1949 pwrap_writel(wrp, crc_val, PWRAP_SIG_ADR);
1950
1951 /* PMIC Wrapper Arbiter priority */
1952 pwrap_writel(wrp,
1953 wrp->master->arb_en_all, PWRAP_HIPRIO_ARB_EN);
1954
1955 return 0;
1956 }
1957
pwrap_mt8135_init_soc_specific(struct pmic_wrapper * wrp)1958 static int pwrap_mt8135_init_soc_specific(struct pmic_wrapper *wrp)
1959 {
1960 /* enable pwrap events and pwrap bridge in AP side */
1961 pwrap_writel(wrp, 0x1, PWRAP_EVENT_IN_EN);
1962 pwrap_writel(wrp, 0xffff, PWRAP_EVENT_DST_EN);
1963 writel(0x7f, wrp->bridge_base + PWRAP_MT8135_BRIDGE_IORD_ARB_EN);
1964 writel(0x1, wrp->bridge_base + PWRAP_MT8135_BRIDGE_WACS3_EN);
1965 writel(0x1, wrp->bridge_base + PWRAP_MT8135_BRIDGE_WACS4_EN);
1966 writel(0x1, wrp->bridge_base + PWRAP_MT8135_BRIDGE_WDT_UNIT);
1967 writel(0xffff, wrp->bridge_base + PWRAP_MT8135_BRIDGE_WDT_SRC_EN);
1968 writel(0x1, wrp->bridge_base + PWRAP_MT8135_BRIDGE_TIMER_EN);
1969 writel(0x7ff, wrp->bridge_base + PWRAP_MT8135_BRIDGE_INT_EN);
1970
1971 /* enable PMIC event out and sources */
1972 if (pwrap_write(wrp, wrp->slave->dew_regs[PWRAP_DEW_EVENT_OUT_EN],
1973 0x1) ||
1974 pwrap_write(wrp, wrp->slave->dew_regs[PWRAP_DEW_EVENT_SRC_EN],
1975 0xffff)) {
1976 dev_err(wrp->dev, "enable dewrap fail\n");
1977 return -EFAULT;
1978 }
1979
1980 return 0;
1981 }
1982
pwrap_mt8173_init_soc_specific(struct pmic_wrapper * wrp)1983 static int pwrap_mt8173_init_soc_specific(struct pmic_wrapper *wrp)
1984 {
1985 /* PMIC_DEWRAP enables */
1986 if (pwrap_write(wrp, wrp->slave->dew_regs[PWRAP_DEW_EVENT_OUT_EN],
1987 0x1) ||
1988 pwrap_write(wrp, wrp->slave->dew_regs[PWRAP_DEW_EVENT_SRC_EN],
1989 0xffff)) {
1990 dev_err(wrp->dev, "enable dewrap fail\n");
1991 return -EFAULT;
1992 }
1993
1994 return 0;
1995 }
1996
pwrap_mt2701_init_soc_specific(struct pmic_wrapper * wrp)1997 static int pwrap_mt2701_init_soc_specific(struct pmic_wrapper *wrp)
1998 {
1999 /* GPS_INTF initialization */
2000 switch (wrp->slave->type) {
2001 case PMIC_MT6323:
2002 pwrap_writel(wrp, 0x076c, PWRAP_ADC_CMD_ADDR);
2003 pwrap_writel(wrp, 0x8000, PWRAP_PWRAP_ADC_CMD);
2004 pwrap_writel(wrp, 0x072c, PWRAP_ADC_RDY_ADDR);
2005 pwrap_writel(wrp, 0x072e, PWRAP_ADC_RDATA_ADDR1);
2006 pwrap_writel(wrp, 0x0730, PWRAP_ADC_RDATA_ADDR2);
2007 break;
2008 default:
2009 break;
2010 }
2011
2012 return 0;
2013 }
2014
pwrap_mt6795_init_soc_specific(struct pmic_wrapper * wrp)2015 static int pwrap_mt6795_init_soc_specific(struct pmic_wrapper *wrp)
2016 {
2017 pwrap_writel(wrp, 0xf, PWRAP_STAUPD_GRPEN);
2018
2019 if (wrp->slave->type == PMIC_MT6331)
2020 pwrap_writel(wrp, 0x1b4, PWRAP_EINT_STA0_ADR);
2021
2022 if (wrp->slave->comp_type == PMIC_MT6332)
2023 pwrap_writel(wrp, 0x8112, PWRAP_EINT_STA1_ADR);
2024
2025 return 0;
2026 }
2027
pwrap_mt7622_init_soc_specific(struct pmic_wrapper * wrp)2028 static int pwrap_mt7622_init_soc_specific(struct pmic_wrapper *wrp)
2029 {
2030 pwrap_writel(wrp, 0, PWRAP_STAUPD_PRD);
2031 /* enable 2wire SPI master */
2032 pwrap_writel(wrp, 0x8000000, PWRAP_SPI2_CTRL);
2033
2034 return 0;
2035 }
2036
pwrap_mt8183_init_soc_specific(struct pmic_wrapper * wrp)2037 static int pwrap_mt8183_init_soc_specific(struct pmic_wrapper *wrp)
2038 {
2039 pwrap_writel(wrp, 0xf5, PWRAP_STAUPD_GRPEN);
2040
2041 pwrap_write(wrp, wrp->slave->dew_regs[PWRAP_DEW_CRC_EN], 0x1);
2042 pwrap_writel(wrp, 1, PWRAP_CRC_EN);
2043 pwrap_writel(wrp, 0x416, PWRAP_SIG_ADR);
2044 pwrap_writel(wrp, 0x42e, PWRAP_EINT_STA0_ADR);
2045
2046 pwrap_writel(wrp, 1, PWRAP_WACS_P2P_EN);
2047 pwrap_writel(wrp, 1, PWRAP_WACS_MD32_EN);
2048 pwrap_writel(wrp, 1, PWRAP_INIT_DONE_P2P);
2049 pwrap_writel(wrp, 1, PWRAP_INIT_DONE_MD32);
2050
2051 return 0;
2052 }
2053
pwrap_init(struct pmic_wrapper * wrp)2054 static int pwrap_init(struct pmic_wrapper *wrp)
2055 {
2056 int ret;
2057
2058 if (wrp->rstc)
2059 reset_control_reset(wrp->rstc);
2060 if (wrp->rstc_bridge)
2061 reset_control_reset(wrp->rstc_bridge);
2062
2063 switch (wrp->master->type) {
2064 case PWRAP_MT6795:
2065 fallthrough;
2066 case PWRAP_MT8173:
2067 /* Enable DCM */
2068 pwrap_writel(wrp, 3, PWRAP_DCM_EN);
2069 pwrap_writel(wrp, 0, PWRAP_DCM_DBC_PRD);
2070 break;
2071 default:
2072 break;
2073 }
2074
2075 if (HAS_CAP(wrp->slave->caps, PWRAP_SLV_CAP_SPI)) {
2076 /* Reset SPI slave */
2077 ret = pwrap_reset_spislave(wrp);
2078 if (ret)
2079 return ret;
2080 }
2081
2082 pwrap_writel(wrp, 1, PWRAP_WRAP_EN);
2083
2084 pwrap_writel(wrp, wrp->master->arb_en_all, PWRAP_HIPRIO_ARB_EN);
2085
2086 pwrap_writel(wrp, 1, PWRAP_WACS2_EN);
2087
2088 ret = wrp->master->init_reg_clock(wrp);
2089 if (ret)
2090 return ret;
2091
2092 if (HAS_CAP(wrp->slave->caps, PWRAP_SLV_CAP_SPI)) {
2093 /* Setup serial input delay */
2094 ret = pwrap_init_sidly(wrp);
2095 if (ret)
2096 return ret;
2097 }
2098
2099 if (HAS_CAP(wrp->slave->caps, PWRAP_SLV_CAP_DUALIO)) {
2100 /* Enable dual I/O mode */
2101 ret = pwrap_init_dual_io(wrp);
2102 if (ret)
2103 return ret;
2104 }
2105
2106 if (HAS_CAP(wrp->slave->caps, PWRAP_SLV_CAP_SECURITY)) {
2107 /* Enable security on bus */
2108 ret = pwrap_init_security(wrp);
2109 if (ret)
2110 return ret;
2111 }
2112
2113 if (wrp->master->type == PWRAP_MT8135)
2114 pwrap_writel(wrp, 0x7, PWRAP_RRARB_EN);
2115
2116 pwrap_writel(wrp, 0x1, PWRAP_WACS0_EN);
2117 pwrap_writel(wrp, 0x1, PWRAP_WACS1_EN);
2118 pwrap_writel(wrp, 0x1, PWRAP_WACS2_EN);
2119 pwrap_writel(wrp, 0x5, PWRAP_STAUPD_PRD);
2120 pwrap_writel(wrp, 0xff, PWRAP_STAUPD_GRPEN);
2121
2122 if (wrp->master->init_soc_specific) {
2123 ret = wrp->master->init_soc_specific(wrp);
2124 if (ret)
2125 return ret;
2126 }
2127
2128 /* Setup the init done registers */
2129 pwrap_writel(wrp, 1, PWRAP_INIT_DONE2);
2130 pwrap_writel(wrp, 1, PWRAP_INIT_DONE0);
2131 pwrap_writel(wrp, 1, PWRAP_INIT_DONE1);
2132
2133 if (HAS_CAP(wrp->master->caps, PWRAP_CAP_BRIDGE)) {
2134 writel(1, wrp->bridge_base + PWRAP_MT8135_BRIDGE_INIT_DONE3);
2135 writel(1, wrp->bridge_base + PWRAP_MT8135_BRIDGE_INIT_DONE4);
2136 }
2137
2138 return 0;
2139 }
2140
pwrap_interrupt(int irqno,void * dev_id)2141 static irqreturn_t pwrap_interrupt(int irqno, void *dev_id)
2142 {
2143 u32 rdata;
2144 struct pmic_wrapper *wrp = dev_id;
2145
2146 rdata = pwrap_readl(wrp, PWRAP_INT_FLG);
2147 dev_err(wrp->dev, "unexpected interrupt int=0x%x\n", rdata);
2148 pwrap_writel(wrp, 0xffffffff, PWRAP_INT_CLR);
2149
2150 if (HAS_CAP(wrp->master->caps, PWRAP_CAP_INT1_EN)) {
2151 rdata = pwrap_readl(wrp, PWRAP_INT1_FLG);
2152 dev_err(wrp->dev, "unexpected interrupt int1=0x%x\n", rdata);
2153 pwrap_writel(wrp, 0xffffffff, PWRAP_INT1_CLR);
2154 }
2155
2156 return IRQ_HANDLED;
2157 }
2158
2159 static const struct regmap_config pwrap_regmap_config16 = {
2160 .reg_bits = 16,
2161 .val_bits = 16,
2162 .reg_stride = 2,
2163 .reg_read = pwrap_regmap_read,
2164 .reg_write = pwrap_regmap_write,
2165 .max_register = 0xffff,
2166 };
2167
2168 static const struct regmap_config pwrap_regmap_config32 = {
2169 .reg_bits = 32,
2170 .val_bits = 32,
2171 .reg_stride = 4,
2172 .reg_read = pwrap_regmap_read,
2173 .reg_write = pwrap_regmap_write,
2174 .max_register = 0xffff,
2175 };
2176
2177 static const struct pwrap_slv_regops pwrap_regops16 = {
2178 .pwrap_read = pwrap_read16,
2179 .pwrap_write = pwrap_write16,
2180 .regmap = &pwrap_regmap_config16,
2181 };
2182
2183 static const struct pwrap_slv_regops pwrap_regops32 = {
2184 .pwrap_read = pwrap_read32,
2185 .pwrap_write = pwrap_write32,
2186 .regmap = &pwrap_regmap_config32,
2187 };
2188
2189 static const struct pwrap_slv_type pmic_mt6323 = {
2190 .dew_regs = mt6323_regs,
2191 .type = PMIC_MT6323,
2192 .regops = &pwrap_regops16,
2193 .caps = PWRAP_SLV_CAP_SPI | PWRAP_SLV_CAP_DUALIO |
2194 PWRAP_SLV_CAP_SECURITY,
2195 };
2196
2197 static const struct pwrap_slv_type pmic_mt6331 = {
2198 .dew_regs = mt6331_regs,
2199 .type = PMIC_MT6331,
2200 .comp_dew_regs = mt6332_regs,
2201 .comp_type = PMIC_MT6332,
2202 .regops = &pwrap_regops16,
2203 .caps = PWRAP_SLV_CAP_SPI | PWRAP_SLV_CAP_DUALIO |
2204 PWRAP_SLV_CAP_SECURITY,
2205 };
2206
2207 static const struct pwrap_slv_type pmic_mt6351 = {
2208 .dew_regs = mt6351_regs,
2209 .type = PMIC_MT6351,
2210 .regops = &pwrap_regops16,
2211 .caps = 0,
2212 };
2213
2214 static const struct pwrap_slv_type pmic_mt6357 = {
2215 .dew_regs = mt6357_regs,
2216 .type = PMIC_MT6357,
2217 .regops = &pwrap_regops16,
2218 .caps = 0,
2219 };
2220
2221 static const struct pwrap_slv_type pmic_mt6358 = {
2222 .dew_regs = mt6358_regs,
2223 .type = PMIC_MT6358,
2224 .regops = &pwrap_regops16,
2225 .caps = PWRAP_SLV_CAP_SPI | PWRAP_SLV_CAP_DUALIO,
2226 };
2227
2228 static const struct pwrap_slv_type pmic_mt6359 = {
2229 .dew_regs = mt6359_regs,
2230 .type = PMIC_MT6359,
2231 .regops = &pwrap_regops16,
2232 .caps = PWRAP_SLV_CAP_DUALIO,
2233 };
2234
2235 static const struct pwrap_slv_type pmic_mt6380 = {
2236 .dew_regs = NULL,
2237 .type = PMIC_MT6380,
2238 .regops = &pwrap_regops32,
2239 .caps = 0,
2240 };
2241
2242 static const struct pwrap_slv_type pmic_mt6397 = {
2243 .dew_regs = mt6397_regs,
2244 .type = PMIC_MT6397,
2245 .regops = &pwrap_regops16,
2246 .caps = PWRAP_SLV_CAP_SPI | PWRAP_SLV_CAP_DUALIO |
2247 PWRAP_SLV_CAP_SECURITY,
2248 };
2249
2250 static const struct of_device_id of_slave_match_tbl[] = {
2251 { .compatible = "mediatek,mt6323", .data = &pmic_mt6323 },
2252 { .compatible = "mediatek,mt6331", .data = &pmic_mt6331 },
2253 { .compatible = "mediatek,mt6351", .data = &pmic_mt6351 },
2254 { .compatible = "mediatek,mt6357", .data = &pmic_mt6357 },
2255 { .compatible = "mediatek,mt6358", .data = &pmic_mt6358 },
2256 { .compatible = "mediatek,mt6359", .data = &pmic_mt6359 },
2257
2258 /* The MT6380 PMIC only implements a regulator, so we bind it
2259 * directly instead of using a MFD.
2260 */
2261 { .compatible = "mediatek,mt6380-regulator", .data = &pmic_mt6380 },
2262 { .compatible = "mediatek,mt6397", .data = &pmic_mt6397 },
2263 { /* sentinel */ }
2264 };
2265 MODULE_DEVICE_TABLE(of, of_slave_match_tbl);
2266
2267 static const struct pmic_wrapper_type pwrap_mt2701 = {
2268 .regs = mt2701_regs,
2269 .type = PWRAP_MT2701,
2270 .arb_en_all = 0x3f,
2271 .int_en_all = ~(u32)(BIT(31) | BIT(2)),
2272 .int1_en_all = 0,
2273 .spi_w = PWRAP_MAN_CMD_SPI_WRITE_NEW,
2274 .wdt_src = PWRAP_WDT_SRC_MASK_ALL,
2275 .caps = PWRAP_CAP_RESET | PWRAP_CAP_DCM,
2276 .init_reg_clock = pwrap_mt2701_init_reg_clock,
2277 .init_soc_specific = pwrap_mt2701_init_soc_specific,
2278 };
2279
2280 static const struct pmic_wrapper_type pwrap_mt6765 = {
2281 .regs = mt6765_regs,
2282 .type = PWRAP_MT6765,
2283 .arb_en_all = 0x3fd35,
2284 .int_en_all = 0xffffffff,
2285 .spi_w = PWRAP_MAN_CMD_SPI_WRITE,
2286 .wdt_src = PWRAP_WDT_SRC_MASK_ALL,
2287 .caps = PWRAP_CAP_RESET | PWRAP_CAP_DCM,
2288 .init_reg_clock = pwrap_common_init_reg_clock,
2289 .init_soc_specific = NULL,
2290 };
2291
2292 static const struct pmic_wrapper_type pwrap_mt6779 = {
2293 .regs = mt6779_regs,
2294 .type = PWRAP_MT6779,
2295 .arb_en_all = 0xfbb7f,
2296 .int_en_all = 0xfffffffe,
2297 .int1_en_all = 0,
2298 .spi_w = PWRAP_MAN_CMD_SPI_WRITE,
2299 .wdt_src = PWRAP_WDT_SRC_MASK_ALL,
2300 .caps = 0,
2301 .init_reg_clock = pwrap_common_init_reg_clock,
2302 .init_soc_specific = NULL,
2303 };
2304
2305 static const struct pmic_wrapper_type pwrap_mt6795 = {
2306 .regs = mt6795_regs,
2307 .type = PWRAP_MT6795,
2308 .arb_en_all = 0x3f,
2309 .int_en_all = ~(u32)(BIT(31) | BIT(2) | BIT(1)),
2310 .int1_en_all = 0,
2311 .spi_w = PWRAP_MAN_CMD_SPI_WRITE,
2312 .wdt_src = PWRAP_WDT_SRC_MASK_NO_STAUPD,
2313 .caps = PWRAP_CAP_RESET | PWRAP_CAP_DCM,
2314 .init_reg_clock = pwrap_common_init_reg_clock,
2315 .init_soc_specific = pwrap_mt6795_init_soc_specific,
2316 };
2317
2318 static const struct pmic_wrapper_type pwrap_mt6797 = {
2319 .regs = mt6797_regs,
2320 .type = PWRAP_MT6797,
2321 .arb_en_all = 0x01fff,
2322 .int_en_all = 0xffffffc6,
2323 .int1_en_all = 0,
2324 .spi_w = PWRAP_MAN_CMD_SPI_WRITE,
2325 .wdt_src = PWRAP_WDT_SRC_MASK_ALL,
2326 .caps = PWRAP_CAP_RESET | PWRAP_CAP_DCM,
2327 .init_reg_clock = pwrap_common_init_reg_clock,
2328 .init_soc_specific = NULL,
2329 };
2330
2331 static const struct pmic_wrapper_type pwrap_mt6873 = {
2332 .regs = mt6873_regs,
2333 .type = PWRAP_MT6873,
2334 .arb_en_all = 0x777f,
2335 .int_en_all = BIT(4) | BIT(5),
2336 .int1_en_all = 0,
2337 .spi_w = PWRAP_MAN_CMD_SPI_WRITE,
2338 .wdt_src = PWRAP_WDT_SRC_MASK_ALL,
2339 .caps = PWRAP_CAP_ARB,
2340 .init_reg_clock = pwrap_common_init_reg_clock,
2341 .init_soc_specific = NULL,
2342 };
2343
2344 static const struct pmic_wrapper_type pwrap_mt7622 = {
2345 .regs = mt7622_regs,
2346 .type = PWRAP_MT7622,
2347 .arb_en_all = 0xff,
2348 .int_en_all = ~(u32)BIT(31),
2349 .int1_en_all = 0,
2350 .spi_w = PWRAP_MAN_CMD_SPI_WRITE,
2351 .wdt_src = PWRAP_WDT_SRC_MASK_ALL,
2352 .caps = PWRAP_CAP_RESET | PWRAP_CAP_DCM,
2353 .init_reg_clock = pwrap_common_init_reg_clock,
2354 .init_soc_specific = pwrap_mt7622_init_soc_specific,
2355 };
2356
2357 static const struct pmic_wrapper_type pwrap_mt8135 = {
2358 .regs = mt8135_regs,
2359 .type = PWRAP_MT8135,
2360 .arb_en_all = 0x1ff,
2361 .int_en_all = ~(u32)(BIT(31) | BIT(1)),
2362 .int1_en_all = 0,
2363 .spi_w = PWRAP_MAN_CMD_SPI_WRITE,
2364 .wdt_src = PWRAP_WDT_SRC_MASK_ALL,
2365 .caps = PWRAP_CAP_BRIDGE | PWRAP_CAP_RESET | PWRAP_CAP_DCM,
2366 .init_reg_clock = pwrap_common_init_reg_clock,
2367 .init_soc_specific = pwrap_mt8135_init_soc_specific,
2368 };
2369
2370 static const struct pmic_wrapper_type pwrap_mt8173 = {
2371 .regs = mt8173_regs,
2372 .type = PWRAP_MT8173,
2373 .arb_en_all = 0x3f,
2374 .int_en_all = ~(u32)(BIT(31) | BIT(1)),
2375 .int1_en_all = 0,
2376 .spi_w = PWRAP_MAN_CMD_SPI_WRITE,
2377 .wdt_src = PWRAP_WDT_SRC_MASK_NO_STAUPD,
2378 .caps = PWRAP_CAP_RESET | PWRAP_CAP_DCM,
2379 .init_reg_clock = pwrap_common_init_reg_clock,
2380 .init_soc_specific = pwrap_mt8173_init_soc_specific,
2381 };
2382
2383 static const struct pmic_wrapper_type pwrap_mt8183 = {
2384 .regs = mt8183_regs,
2385 .type = PWRAP_MT8183,
2386 .arb_en_all = 0x3fa75,
2387 .int_en_all = 0xffffffff,
2388 .int1_en_all = 0xeef7ffff,
2389 .spi_w = PWRAP_MAN_CMD_SPI_WRITE,
2390 .wdt_src = PWRAP_WDT_SRC_MASK_ALL,
2391 .caps = PWRAP_CAP_INT1_EN | PWRAP_CAP_WDT_SRC1,
2392 .init_reg_clock = pwrap_common_init_reg_clock,
2393 .init_soc_specific = pwrap_mt8183_init_soc_specific,
2394 };
2395
2396 static const struct pmic_wrapper_type pwrap_mt8195 = {
2397 .regs = mt8195_regs,
2398 .type = PWRAP_MT8195,
2399 .arb_en_all = 0x777f, /* NEED CONFIRM */
2400 .int_en_all = 0x180000, /* NEED CONFIRM */
2401 .int1_en_all = 0,
2402 .spi_w = PWRAP_MAN_CMD_SPI_WRITE,
2403 .wdt_src = PWRAP_WDT_SRC_MASK_ALL,
2404 .caps = PWRAP_CAP_INT1_EN | PWRAP_CAP_ARB,
2405 .init_reg_clock = pwrap_common_init_reg_clock,
2406 .init_soc_specific = NULL,
2407 };
2408
2409 static const struct pmic_wrapper_type pwrap_mt8365 = {
2410 .regs = mt8365_regs,
2411 .type = PWRAP_MT8365,
2412 .arb_en_all = 0x3ffff,
2413 .int_en_all = 0x7f1fffff,
2414 .int1_en_all = 0x0,
2415 .spi_w = PWRAP_MAN_CMD_SPI_WRITE,
2416 .wdt_src = PWRAP_WDT_SRC_MASK_ALL,
2417 .caps = PWRAP_CAP_INT1_EN | PWRAP_CAP_WDT_SRC1,
2418 .init_reg_clock = pwrap_common_init_reg_clock,
2419 .init_soc_specific = NULL,
2420 };
2421
2422 static const struct pmic_wrapper_type pwrap_mt8516 = {
2423 .regs = mt8516_regs,
2424 .type = PWRAP_MT8516,
2425 .arb_en_all = 0xff,
2426 .int_en_all = ~(u32)(BIT(31) | BIT(2)),
2427 .spi_w = PWRAP_MAN_CMD_SPI_WRITE,
2428 .wdt_src = PWRAP_WDT_SRC_MASK_ALL,
2429 .caps = PWRAP_CAP_DCM,
2430 .init_reg_clock = pwrap_mt2701_init_reg_clock,
2431 .init_soc_specific = NULL,
2432 };
2433
2434 static const struct pmic_wrapper_type pwrap_mt8186 = {
2435 .regs = mt8186_regs,
2436 .type = PWRAP_MT8186,
2437 .arb_en_all = 0xfb27f,
2438 .int_en_all = 0xfffffffe, /* disable WatchDog Timeout for bit 1 */
2439 .int1_en_all = 0x000017ff, /* disable Matching interrupt for bit 13 */
2440 .spi_w = PWRAP_MAN_CMD_SPI_WRITE,
2441 .wdt_src = PWRAP_WDT_SRC_MASK_ALL,
2442 .caps = PWRAP_CAP_INT1_EN | PWRAP_CAP_ARB_MT8186,
2443 .init_reg_clock = pwrap_common_init_reg_clock,
2444 .init_soc_specific = NULL,
2445 };
2446
2447 static const struct of_device_id of_pwrap_match_tbl[] = {
2448 { .compatible = "mediatek,mt2701-pwrap", .data = &pwrap_mt2701 },
2449 { .compatible = "mediatek,mt6765-pwrap", .data = &pwrap_mt6765 },
2450 { .compatible = "mediatek,mt6779-pwrap", .data = &pwrap_mt6779 },
2451 { .compatible = "mediatek,mt6795-pwrap", .data = &pwrap_mt6795 },
2452 { .compatible = "mediatek,mt6797-pwrap", .data = &pwrap_mt6797 },
2453 { .compatible = "mediatek,mt6873-pwrap", .data = &pwrap_mt6873 },
2454 { .compatible = "mediatek,mt7622-pwrap", .data = &pwrap_mt7622 },
2455 { .compatible = "mediatek,mt8135-pwrap", .data = &pwrap_mt8135 },
2456 { .compatible = "mediatek,mt8173-pwrap", .data = &pwrap_mt8173 },
2457 { .compatible = "mediatek,mt8183-pwrap", .data = &pwrap_mt8183 },
2458 { .compatible = "mediatek,mt8186-pwrap", .data = &pwrap_mt8186 },
2459 { .compatible = "mediatek,mt8195-pwrap", .data = &pwrap_mt8195 },
2460 { .compatible = "mediatek,mt8365-pwrap", .data = &pwrap_mt8365 },
2461 { .compatible = "mediatek,mt8516-pwrap", .data = &pwrap_mt8516 },
2462 { /* sentinel */ }
2463 };
2464 MODULE_DEVICE_TABLE(of, of_pwrap_match_tbl);
2465
pwrap_probe(struct platform_device * pdev)2466 static int pwrap_probe(struct platform_device *pdev)
2467 {
2468 int ret, irq;
2469 u32 mask_done;
2470 struct pmic_wrapper *wrp;
2471 struct clk_bulk_data *clk;
2472 struct device_node *np = pdev->dev.of_node;
2473 const struct of_device_id *of_slave_id = NULL;
2474
2475 if (np->child)
2476 of_slave_id = of_match_node(of_slave_match_tbl, np->child);
2477
2478 if (!of_slave_id) {
2479 dev_dbg(&pdev->dev, "slave pmic should be defined in dts\n");
2480 return -EINVAL;
2481 }
2482
2483 wrp = devm_kzalloc(&pdev->dev, sizeof(*wrp), GFP_KERNEL);
2484 if (!wrp)
2485 return -ENOMEM;
2486
2487 platform_set_drvdata(pdev, wrp);
2488
2489 wrp->master = of_device_get_match_data(&pdev->dev);
2490 wrp->slave = of_slave_id->data;
2491 wrp->dev = &pdev->dev;
2492
2493 wrp->base = devm_platform_ioremap_resource_byname(pdev, "pwrap");
2494 if (IS_ERR(wrp->base))
2495 return PTR_ERR(wrp->base);
2496
2497 if (HAS_CAP(wrp->master->caps, PWRAP_CAP_RESET)) {
2498 wrp->rstc = devm_reset_control_get(wrp->dev, "pwrap");
2499 if (IS_ERR(wrp->rstc)) {
2500 ret = PTR_ERR(wrp->rstc);
2501 dev_dbg(wrp->dev, "cannot get pwrap reset: %d\n", ret);
2502 return ret;
2503 }
2504 }
2505
2506 if (HAS_CAP(wrp->master->caps, PWRAP_CAP_BRIDGE)) {
2507 wrp->bridge_base = devm_platform_ioremap_resource_byname(pdev, "pwrap-bridge");
2508 if (IS_ERR(wrp->bridge_base))
2509 return PTR_ERR(wrp->bridge_base);
2510
2511 wrp->rstc_bridge = devm_reset_control_get(wrp->dev,
2512 "pwrap-bridge");
2513 if (IS_ERR(wrp->rstc_bridge)) {
2514 ret = PTR_ERR(wrp->rstc_bridge);
2515 dev_dbg(wrp->dev,
2516 "cannot get pwrap-bridge reset: %d\n", ret);
2517 return ret;
2518 }
2519 }
2520
2521 ret = devm_clk_bulk_get_all_enable(wrp->dev, &clk);
2522 if (ret)
2523 return dev_err_probe(wrp->dev, ret,
2524 "failed to get clocks\n");
2525
2526 /* Enable internal dynamic clock */
2527 if (HAS_CAP(wrp->master->caps, PWRAP_CAP_DCM)) {
2528 pwrap_writel(wrp, 1, PWRAP_DCM_EN);
2529 pwrap_writel(wrp, 0, PWRAP_DCM_DBC_PRD);
2530 }
2531
2532 /*
2533 * The PMIC could already be initialized by the bootloader.
2534 * Skip initialization here in this case.
2535 */
2536 if (!pwrap_readl(wrp, PWRAP_INIT_DONE2)) {
2537 ret = pwrap_init(wrp);
2538 if (ret) {
2539 dev_dbg(wrp->dev, "init failed with %d\n", ret);
2540 return ret;
2541 }
2542 }
2543
2544 if (HAS_CAP(wrp->master->caps, PWRAP_CAP_ARB))
2545 mask_done = PWRAP_STATE_INIT_DONE1;
2546 else if (HAS_CAP(wrp->master->caps, PWRAP_CAP_ARB_MT8186))
2547 mask_done = PWRAP_STATE_INIT_DONE0_MT8186;
2548 else
2549 mask_done = PWRAP_STATE_INIT_DONE0;
2550
2551 if (!(pwrap_readl(wrp, PWRAP_WACS2_RDATA) & mask_done)) {
2552 dev_dbg(wrp->dev, "initialization isn't finished\n");
2553 return -ENODEV;
2554 }
2555
2556 /* Initialize watchdog, may not be done by the bootloader */
2557 if (!HAS_CAP(wrp->master->caps, PWRAP_CAP_ARB))
2558 pwrap_writel(wrp, 0xf, PWRAP_WDT_UNIT);
2559
2560 /*
2561 * Since STAUPD was not used on mt8173 platform,
2562 * so STAUPD of WDT_SRC which should be turned off
2563 */
2564 pwrap_writel(wrp, wrp->master->wdt_src, PWRAP_WDT_SRC_EN);
2565 if (HAS_CAP(wrp->master->caps, PWRAP_CAP_WDT_SRC1))
2566 pwrap_writel(wrp, wrp->master->wdt_src, PWRAP_WDT_SRC_EN_1);
2567
2568 if (HAS_CAP(wrp->master->caps, PWRAP_CAP_ARB))
2569 pwrap_writel(wrp, 0x3, PWRAP_TIMER_EN);
2570 else
2571 pwrap_writel(wrp, 0x1, PWRAP_TIMER_EN);
2572
2573 pwrap_writel(wrp, wrp->master->int_en_all, PWRAP_INT_EN);
2574 /*
2575 * We add INT1 interrupt to handle starvation and request exception
2576 * If we support it, we should enable it here.
2577 */
2578 if (HAS_CAP(wrp->master->caps, PWRAP_CAP_INT1_EN))
2579 pwrap_writel(wrp, wrp->master->int1_en_all, PWRAP_INT1_EN);
2580
2581 irq = platform_get_irq(pdev, 0);
2582 if (irq < 0)
2583 return irq;
2584
2585 ret = devm_request_irq(wrp->dev, irq, pwrap_interrupt,
2586 IRQF_TRIGGER_HIGH,
2587 "mt-pmic-pwrap", wrp);
2588 if (ret)
2589 return ret;
2590
2591 wrp->regmap = devm_regmap_init(wrp->dev, NULL, wrp, wrp->slave->regops->regmap);
2592 if (IS_ERR(wrp->regmap))
2593 return PTR_ERR(wrp->regmap);
2594
2595 ret = of_platform_populate(np, NULL, NULL, wrp->dev);
2596 if (ret) {
2597 dev_dbg(wrp->dev, "failed to create child devices at %pOF\n",
2598 np);
2599 return ret;
2600 }
2601
2602 return 0;
2603 }
2604
2605 static struct platform_driver pwrap_drv = {
2606 .driver = {
2607 .name = "mt-pmic-pwrap",
2608 .of_match_table = of_pwrap_match_tbl,
2609 },
2610 .probe = pwrap_probe,
2611 };
2612
2613 module_platform_driver(pwrap_drv);
2614
2615 MODULE_AUTHOR("Flora Fu, MediaTek");
2616 MODULE_DESCRIPTION("MediaTek MT8135 PMIC Wrapper Driver");
2617 MODULE_LICENSE("GPL v2");
2618