1 /*
2 * Copyright 2018 AllWinnertech Co., Ltd
3 * wangwei@allwinnertech.com
4 */
5 #include <stdio.h>
6 #include <string.h>
7
8 #include <sunxi_hal_efuse.h>
9 #include <sunxi_hal_common.h>
10
11 #include "platform_efuse.h"
12 #include "efuse.h"
13
14 #if (EFUSE_DBG_EN & (CONFIG_LOG_DEFAULT_LEVEL != 0))
15 #define EFUSE_DBG(fmt,args...) printf(fmt ,##args)
16 #define EFUSE_DUMP_LEN 16
17 #define EFUSE_DBG_DUMP(key_name, key_data, key_len) efuse_dump(key_name, key_data, key_len, EFUSE_DUMP_LEN)
18 #else
19 #define EFUSE_DBG(fmt,args...)
20 #define EFUSE_DBG_DUMP(...) do{} while(0);
21 #endif
22
23
24 #if EFUSE_DBG_EN
efuse_dump(char * str,unsigned char * data,int len,int align)25 static void efuse_dump(char *str,unsigned char *data,\
26 int len, int align)
27 {
28 int i = 0;
29 if(str)
30 printf("\n%s: ",str);
31 for(i = 0; i<len; i++)
32 {
33 if((i%align) == 0)
34 {
35 printf("\n");
36 }
37 printf("%02x ",*(data++));
38 }
39 printf("\n");
40 }
41 #endif
42
hal_efuse_write(char * key_name,unsigned char * key_data,size_t key_bit_len)43 int hal_efuse_write(char *key_name, unsigned char *key_data, size_t key_bit_len)
44 {
45 unsigned long k_src = 0;
46 unsigned int niddle = 0,tmp_data = 0,k_d_lft = 0 ;
47 size_t key_len = key_bit_len>>3;
48 efuse_key_map_new_t *key_map;
49 int ret;
50
51 if ((strlen(key_name) == 0)|| (key_len == 0) || ((unsigned long)key_data%4 != 0))
52 return EFUSE_ERR_ARG;
53
54 key_map = efuse_search_key_by_name(key_name);
55
56 if (((unsigned int)key_map->size >> 3) < key_len) {
57 EFUSE_DBG("key name = %s\n", key_map->name);
58 return EFUSE_ERR_KEY_SIZE_TOO_BIG;
59 }
60
61 if (key_map->size == 0) {
62 EFUSE_DBG("%s: error: unknow key\n", __func__);
63 return EFUSE_ERR_KEY_NAME_WRONG;
64 }
65
66 ret = efuse_acl_ck(key_map, 1);
67 if(ret) {
68 EFUSE_DBG("%s: __efuse_acl_ck check failed\n", __func__);
69 return ret;
70 }
71 EFUSE_DBG_DUMP(key_name, key_data, key_len);
72
73 /*rotpk need double check before burn*/
74 if (strcmp(key_name, "rotpk") == 0) {
75 }
76
77 niddle = key_map->offset;
78 k_d_lft = key_len;
79 k_src = (unsigned long)key_data;
80
81 while(k_d_lft >= 4) {
82 tmp_data = *(unsigned int*)k_src;
83 EFUSE_DBG("offset:0x%x val:0x%x\n",niddle,tmp_data);
84 if(tmp_data)
85 {
86 if(efuse_uni_burn_key(niddle, tmp_data))
87 {
88 return EFUSE_ERR_BURN_TIMING;
89 }
90 }
91 k_d_lft-=4;
92 niddle += 4;
93 k_src +=4;
94 }
95
96 if(k_d_lft) {
97 uint mask = (1UL << (k_d_lft << 3)) - 1;
98 tmp_data = *(unsigned int*)k_src;
99 mask &= tmp_data;
100 EFUSE_DBG("offset:0x%x val:0x%x\n",niddle,mask);
101 if(mask)
102 {
103 if(efuse_uni_burn_key(niddle,mask))
104 {
105 return EFUSE_ERR_BURN_TIMING;
106 }
107 }
108 }
109 /*Already burned bit: Set this bit to indicate it is already burned.*/
110 if ((key_map->burned_flg_offset >= 0) &&
111 (key_map->burned_flg_offset <= EFUSE_BRUN_RD_OFFSET_MASK)) {
112 efuse_set_cfg_flg(EFUSE_WRITE_PROTECT,key_map->burned_flg_offset);
113 }
114
115 /*Read forbidden bit: Set to indicate cpu can not access this key again.*/
116 if ((key_map->rd_fbd_offset >= 0) &&
117 (key_map->rd_fbd_offset <= EFUSE_BRUN_RD_OFFSET_MASK)) {
118 efuse_set_cfg_flg(EFUSE_READ_PROTECT,key_map->rd_fbd_offset);
119 }
120
121 return 0;
122 }
123
124 /*This API assume the caller already
125 *prepared enough buffer to receive data.
126 *Because the lenth of key is exported as MACRO*/
127 #define EFUSE_ROUND_UP(x,y) ((((x) + ((y) - 1)) / (y)) * (y))
hal_efuse_read(char * key_name,unsigned char * key_data,size_t key_bit_len)128 int hal_efuse_read(char *key_name, unsigned char *key_data, size_t key_bit_len)
129 {
130 efuse_key_map_new_t *key_map;
131 uint tmp=0,i=0,k_u32_l=0,bit_lft = 0;
132 int offset =0,tmp_sz = 0;
133 int ret;
134 /*if key_data not aligned ,u32_p will not be accessed*/
135 unsigned int *u32_p = (unsigned int *)key_data;
136 unsigned char *u8_p = (unsigned char *)key_data;
137 if(!(key_name && key_data)) {
138 EFUSE_DBG("[efuse] error arg: key_name is %p, key_data is %p\n",key_name, key_data);
139 return EFUSE_ERR_ARG;
140 }
141
142 key_map = efuse_search_key_by_name(key_name);
143
144 if (key_map->size == 0 || key_map->size > key_bit_len) {
145 EFUSE_DBG("[efuse] error: unknow key name\n");
146 return EFUSE_ERR_KEY_NAME_WRONG;
147 }
148
149 ret = efuse_acl_ck(key_map, 0);
150 if(ret) {
151 EFUSE_DBG("[sunxi_efuse_write] error: acl check fail\n");
152 return ret;
153 }
154 EFUSE_DBG("key name:%s key size:%d key offset:%d\n",\
155 key_map->name,key_map->size,key_map->offset);
156
157 if (key_map->size > key_bit_len) {
158 EFUSE_DBG("[efuse] error: key size\n");
159 return EFUSE_ERR_ARG;
160 }
161
162 k_u32_l = key_map->size / 32;
163 bit_lft = key_map->size % 32;
164 offset = key_map->offset;
165
166 for(i = 0;i<k_u32_l;i++)
167 {
168 tmp = efuse_sram_read_key(offset);
169 if(((unsigned long)key_data & 0x3) == 0)
170 {
171 u32_p[i] = tmp;
172 }
173 else
174 {
175 memcpy((void*)(u8_p + i * 4),(void*)(&tmp),4);
176 }
177 offset += 4;
178 tmp_sz += 4;
179 }
180
181 if(bit_lft)
182 {
183 EFUSE_DBG("bit lft is %d\n",bit_lft);
184 tmp = efuse_sram_read_key(offset);
185 memcpy((void*)(u8_p + k_u32_l * 4),(void*)(&tmp),
186 EFUSE_ROUND_UP(bit_lft,8) / 8);
187 tmp_sz += (EFUSE_ROUND_UP(bit_lft,8) / 8);
188 }
189
190 EFUSE_DBG_DUMP(key_name, key_data, key_bit_len/8);
191
192 return tmp_sz;
193 }
194
hal_efuse_set_security_mode(void)195 int hal_efuse_set_security_mode(void)
196 {
197 #ifdef EFUSE_LCJS
198 return efuse_uni_burn_key(EFUSE_LCJS, 0x1 << SECURE_BIT_OFFSET);
199 #else
200 return 0;
201 #endif
202 }
203
204
hal_efuse_get_security_mode(void)205 int hal_efuse_get_security_mode(void)
206 {
207 #ifdef EFUSE_SECURE_MODE
208 return hal_readl(EFUSE_SECURE_MODE) & 0x1;
209 #else
210 return 0;
211 #endif
212 }
213
hal_efuse_get_chipid(unsigned char * buffer)214 int hal_efuse_get_chipid(unsigned char *buffer)
215 {
216 return hal_efuse_read("chipid", buffer, 128);
217 }
218
hal_efuse_get_thermal_cdata(unsigned char * buffer)219 int hal_efuse_get_thermal_cdata(unsigned char *buffer)
220 {
221 return hal_efuse_read("thermal_sensor", buffer, 64);
222 }
223
224