2 * Copyright 2011 Advanced Micro Devices, Inc.
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
22 * Authors: Alex Deucher
25 #include <linux/firmware.h>
30 #include "radeon_ucode.h"
32 int si_set_smc_sram_address(struct radeon_device
*rdev
,
33 u32 smc_address
, u32 limit
)
37 if ((smc_address
+ 3) > limit
)
40 WREG32(SMC_IND_INDEX_0
, smc_address
);
41 WREG32_P(SMC_IND_ACCESS_CNTL
, 0, ~AUTO_INCREMENT_IND_0
);
46 int si_copy_bytes_to_smc(struct radeon_device
*rdev
,
47 u32 smc_start_address
,
48 const u8
*src
, u32 byte_count
, u32 limit
)
51 u32 data
, original_data
, addr
, extra_shift
;
53 if (smc_start_address
& 3)
55 if ((smc_start_address
+ byte_count
) > limit
)
58 addr
= smc_start_address
;
60 while (byte_count
>= 4) {
61 /* SMC address space is BE */
62 data
= (src
[0] << 24) | (src
[1] << 16) | (src
[2] << 8) | src
[3];
64 ret
= si_set_smc_sram_address(rdev
, addr
, limit
);
68 WREG32(SMC_IND_DATA_0
, data
);
75 /* RMW for the final bytes */
79 ret
= si_set_smc_sram_address(rdev
, addr
, limit
);
83 original_data
= RREG32(SMC_IND_DATA_0
);
85 extra_shift
= 8 * (4 - byte_count
);
87 while (byte_count
> 0) {
88 /* SMC address space is BE */
89 data
= (data
<< 8) + *src
++;
95 data
|= (original_data
& ~((~0UL) << extra_shift
));
97 ret
= si_set_smc_sram_address(rdev
, addr
, limit
);
101 WREG32(SMC_IND_DATA_0
, data
);
106 void si_start_smc(struct radeon_device
*rdev
)
108 u32 tmp
= RREG32_SMC(SMC_SYSCON_RESET_CNTL
);
112 WREG32_SMC(SMC_SYSCON_RESET_CNTL
, tmp
);
115 void si_reset_smc(struct radeon_device
*rdev
)
119 RREG32(CB_CGTT_SCLK_CTRL
);
120 RREG32(CB_CGTT_SCLK_CTRL
);
121 RREG32(CB_CGTT_SCLK_CTRL
);
122 RREG32(CB_CGTT_SCLK_CTRL
);
124 tmp
= RREG32_SMC(SMC_SYSCON_RESET_CNTL
);
126 WREG32_SMC(SMC_SYSCON_RESET_CNTL
, tmp
);
129 int si_program_jump_on_start(struct radeon_device
*rdev
)
131 static u8 data
[] = { 0x0E, 0x00, 0x40, 0x40 };
133 return si_copy_bytes_to_smc(rdev
, 0x0, data
, 4, sizeof(data
)+1);
136 void si_stop_smc_clock(struct radeon_device
*rdev
)
138 u32 tmp
= RREG32_SMC(SMC_SYSCON_CLOCK_CNTL_0
);
142 WREG32_SMC(SMC_SYSCON_CLOCK_CNTL_0
, tmp
);
145 void si_start_smc_clock(struct radeon_device
*rdev
)
147 u32 tmp
= RREG32_SMC(SMC_SYSCON_CLOCK_CNTL_0
);
151 WREG32_SMC(SMC_SYSCON_CLOCK_CNTL_0
, tmp
);
154 bool si_is_smc_running(struct radeon_device
*rdev
)
156 u32 rst
= RREG32_SMC(SMC_SYSCON_RESET_CNTL
);
157 u32 clk
= RREG32_SMC(SMC_SYSCON_CLOCK_CNTL_0
);
159 if (!(rst
& RST_REG
) && !(clk
& CK_DISABLE
))
165 PPSMC_Result
si_send_msg_to_smc(struct radeon_device
*rdev
, PPSMC_Msg msg
)
170 if (!si_is_smc_running(rdev
))
171 return PPSMC_Result_Failed
;
173 WREG32(SMC_MESSAGE_0
, msg
);
175 for (i
= 0; i
< rdev
->usec_timeout
; i
++) {
176 tmp
= RREG32(SMC_RESP_0
);
181 tmp
= RREG32(SMC_RESP_0
);
183 return (PPSMC_Result
)tmp
;
186 PPSMC_Result
si_wait_for_smc_inactive(struct radeon_device
*rdev
)
191 if (!si_is_smc_running(rdev
))
192 return PPSMC_Result_OK
;
194 for (i
= 0; i
< rdev
->usec_timeout
; i
++) {
195 tmp
= RREG32_SMC(SMC_SYSCON_CLOCK_CNTL_0
);
196 if ((tmp
& CKEN
) == 0)
201 return PPSMC_Result_OK
;
204 int si_load_smc_ucode(struct radeon_device
*rdev
, u32 limit
)
206 u32 ucode_start_address
;
214 switch (rdev
->family
) {
216 ucode_start_address
= TAHITI_SMC_UCODE_START
;
217 ucode_size
= TAHITI_SMC_UCODE_SIZE
;
220 ucode_start_address
= PITCAIRN_SMC_UCODE_START
;
221 ucode_size
= PITCAIRN_SMC_UCODE_SIZE
;
224 ucode_start_address
= VERDE_SMC_UCODE_START
;
225 ucode_size
= VERDE_SMC_UCODE_SIZE
;
228 ucode_start_address
= OLAND_SMC_UCODE_START
;
229 ucode_size
= OLAND_SMC_UCODE_SIZE
;
232 ucode_start_address
= HAINAN_SMC_UCODE_START
;
233 ucode_size
= HAINAN_SMC_UCODE_SIZE
;
236 DRM_ERROR("unknown asic in smc ucode loader\n");
243 src
= (const u8
*)rdev
->smc_fw
->data
;
244 WREG32(SMC_IND_INDEX_0
, ucode_start_address
);
245 WREG32_P(SMC_IND_ACCESS_CNTL
, AUTO_INCREMENT_IND_0
, ~AUTO_INCREMENT_IND_0
);
246 while (ucode_size
>= 4) {
247 /* SMC address space is BE */
248 data
= (src
[0] << 24) | (src
[1] << 16) | (src
[2] << 8) | src
[3];
250 WREG32(SMC_IND_DATA_0
, data
);
255 WREG32_P(SMC_IND_ACCESS_CNTL
, 0, ~AUTO_INCREMENT_IND_0
);
260 int si_read_smc_sram_dword(struct radeon_device
*rdev
, u32 smc_address
,
261 u32
*value
, u32 limit
)
265 ret
= si_set_smc_sram_address(rdev
, smc_address
, limit
);
269 *value
= RREG32(SMC_IND_DATA_0
);
273 int si_write_smc_sram_dword(struct radeon_device
*rdev
, u32 smc_address
,
274 u32 value
, u32 limit
)
278 ret
= si_set_smc_sram_address(rdev
, smc_address
, limit
);
282 WREG32(SMC_IND_DATA_0
, value
);
This page took 0.057159 seconds and 5 git commands to generate.