blob: 747b527dff04be49f136296a11e02632308f4829
1 | #include <stdio.h> |
2 | #include <stdlib.h> |
3 | #include <string.h> |
4 | #include <unistd.h> |
5 | #include <fcntl.h> |
6 | #include <errno.h> |
7 | #include <sys/stat.h> |
8 | #include <sys/wait.h> |
9 | #include <cutils/properties.h> |
10 | |
11 | #include <netinet/ether.h> |
12 | #include <netinet/if_ether.h> |
13 | |
14 | #include <netutils/ifc.h> |
15 | #include <netutils/dhcp.h> |
16 | |
17 | #include "tvconfig/tvconfig.h" |
18 | #include "CTvSettingCfg.h" |
19 | #include "TvKeyData.h" |
20 | |
21 | |
22 | static unsigned char mHDCPKeyDefHeaderBuf[CC_HDCP_KEY_HEAD_SIZE] = { |
23 | //40 bytes |
24 | 0x53, 0x4B, 0x59, 0x01, 0x00, 0x10, 0x0D, 0x15, 0x3A, 0x8E, // 000~009 |
25 | 0x99, 0xEE, 0x2A, 0x55, 0x58, 0xEE, 0xED, 0x4B, 0xBE, 0x00, // 010~019 |
26 | 0x74, 0xA9, 0x00, 0x10, 0x0A, 0x21, 0xE3, 0x30, 0x66, 0x34, // 020~029 |
27 | 0xCE, 0x9C, 0xC7, 0x8B, 0x51, 0x27, 0xF9, 0x0B, 0xAD, 0x09, // 030~039 |
28 | }; |
29 | |
30 | static unsigned char mDefHDCPKeyContentBuf[CC_HDCP_KEY_CONTENT_SIZE] = { |
31 | //328 bytes |
32 | 0x5F, 0x4D, 0xC2, 0xCA, 0xA2, 0x13, 0x06, 0x18, 0x8D, 0x34, // 000~009 |
33 | 0x82, 0x46, 0x2D, 0xC9, 0x4B, 0xB0, 0x1C, 0xDE, 0x3D, 0x49, // 010~019 |
34 | 0x39, 0x58, 0xEF, 0x2B, 0x68, 0x39, 0x71, 0xC9, 0x4D, 0x25, // 020~029 |
35 | 0xE9, 0x75, 0x4D, 0xAC, 0x62, 0xF5, 0xF5, 0x87, 0xA0, 0xB2, // 030~039 |
36 | 0x4A, 0x60, 0xD3, 0xF1, 0x09, 0x3A, 0xB2, 0x3E, 0x19, 0x4F, // 040~049 |
37 | 0x3B, 0x1B, 0x2F, 0x85, 0x14, 0x28, 0x44, 0xFC, 0x69, 0x6F, // 050~059 |
38 | 0x50, 0x42, 0x81, 0xBF, 0x7C, 0x2B, 0x3A, 0x17, 0x2C, 0x15, // 060~069 |
39 | 0xE4, 0x93, 0x77, 0x74, 0xE8, 0x1F, 0x1C, 0x38, 0x54, 0x49, // 070~079 |
40 | 0x10, 0x64, 0x5B, 0x7D, 0x90, 0x3D, 0xA0, 0xE1, 0x8B, 0x67, // 080~089 |
41 | 0x5C, 0x19, 0xE6, 0xCA, 0x9D, 0xE9, 0x68, 0x5A, 0xB5, 0x62, // 090~099 |
42 | 0xDF, 0xA1, 0x28, 0xBC, 0x68, 0x82, 0x9A, 0x22, 0xC4, 0xDC, // 100~109 |
43 | 0x48, 0x85, 0x0F, 0xF1, 0x3E, 0x05, 0xDD, 0x1B, 0x2D, 0xF5, // 120~119 |
44 | 0x49, 0x3A, 0x15, 0x29, 0xE7, 0xB6, 0x0B, 0x2A, 0x40, 0xE3, // 120~129 |
45 | 0xB0, 0x89, 0xD5, 0x75, 0x84, 0x2E, 0x76, 0xE7, 0xBC, 0x63, // 130~139 |
46 | 0x67, 0xE3, 0x57, 0x67, 0x86, 0x81, 0xF4, 0xD7, 0xEA, 0x4D, // 140~149 |
47 | 0x89, 0x8E, 0x37, 0x95, 0x59, 0x1C, 0x8A, 0xCD, 0x79, 0xF8, // 150~159 |
48 | 0x4F, 0x82, 0xF2, 0x6C, 0x7E, 0x7F, 0x79, 0x8A, 0x6B, 0x90, // 160~169 |
49 | 0xC0, 0xAF, 0x4C, 0x8D, 0x43, 0x47, 0x1F, 0x9A, 0xF1, 0xBB, // 170~179 |
50 | 0x88, 0x64, 0x49, 0x14, 0x50, 0xD1, 0xC3, 0xDF, 0xA6, 0x87, // 180~189 |
51 | 0xA0, 0x15, 0x98, 0x51, 0x81, 0xF5, 0x97, 0x55, 0x10, 0x4A, // 190~199 |
52 | 0x99, 0x30, 0x54, 0xA4, 0xFC, 0xDA, 0x0E, 0xAC, 0x6A, 0xFA, // 200~209 |
53 | 0x90, 0xEE, 0x12, 0x70, 0x69, 0x74, 0x63, 0x46, 0x63, 0xFB, // 210~219 |
54 | 0xE6, 0x1F, 0x72, 0xEC, 0x43, 0x5D, 0x50, 0xFF, 0x03, 0x4F, // 220~229 |
55 | 0x05, 0x33, 0x88, 0x36, 0x93, 0xE4, 0x72, 0xD5, 0xCC, 0x34, // 230~239 |
56 | 0x52, 0x96, 0x15, 0xCE, 0xD0, 0x32, 0x52, 0x41, 0x4F, 0xBC, // 240~249 |
57 | 0x2D, 0xDF, 0xC5, 0xD6, 0x7F, 0xD5, 0x74, 0xCE, 0x51, 0xDC, // 250~259 |
58 | 0x10, 0x5E, 0xF7, 0xAA, 0x4A, 0x2D, 0x20, 0x9A, 0x17, 0xDD, // 260~269 |
59 | 0x30, 0x89, 0x71, 0x82, 0x36, 0x50, 0x09, 0x1F, 0x7C, 0xF3, // 270~279 |
60 | 0x12, 0xE9, 0x43, 0x10, 0x5F, 0x51, 0xBF, 0xB8, 0x45, 0xA8, // 280~289 |
61 | 0x5A, 0x8D, 0x3F, 0x77, 0xE5, 0x96, 0x73, 0x68, 0xAB, 0x73, // 290~299 |
62 | 0xE5, 0x4C, 0xFB, 0xE5, 0x98, 0xB9, 0xAE, 0x74, 0xEB, 0x51, // 300~309 |
63 | 0xDB, 0x91, 0x07, 0x7B, 0x66, 0x02, 0x9B, 0x79, 0x03, 0xC5, // 310~319 |
64 | 0x34, 0x1C, 0x58, 0x13, 0x31, 0xD2, 0x4A, 0xEC, // 320~327 |
65 | }; |
66 | |
67 | |
68 | static int TransStringToHex(int data_cnt, char data_buf[], |
69 | unsigned char hex_buf[]) |
70 | { |
71 | int i = 0, j = 0, tmp_val = 0; |
72 | char tmp_buf[3] = { 0, 0, 0 }; |
73 | |
74 | while (i < data_cnt) { |
75 | tmp_val = 0; |
76 | tmp_buf[0] = data_buf[i]; |
77 | tmp_buf[1] = data_buf[i + 1]; |
78 | tmp_val = strtoul(tmp_buf, NULL, 16); |
79 | hex_buf[j] = tmp_val; |
80 | //LOGD("%s, hex_buf[%d] = 0x%x\n", __FUNCTION__, j, hex_buf[j]); |
81 | i += 2; |
82 | j += 1; |
83 | } |
84 | |
85 | return j; |
86 | } |
87 | |
88 | static int TransToHexString(int hex_cnt, char data_buf[], |
89 | unsigned char hex_buf[]) |
90 | { |
91 | int i = 0, j = 0; |
92 | char tmp_buf[17] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; |
93 | |
94 | data_buf[0] = 0; |
95 | for (i = 0; i < hex_cnt; i++) { |
96 | sprintf(tmp_buf, "%02X", (unsigned char) hex_buf[i]); |
97 | strcat(data_buf, tmp_buf); |
98 | } |
99 | |
100 | return 2 * hex_cnt; |
101 | } |
102 | |
103 | int ReadKeyData(const char *key_name, unsigned char data_buf[]) |
104 | { |
105 | FILE *dev_fp = NULL; |
106 | int i = 0, rd_cnt = 0; |
107 | |
108 | dev_fp = fopen(CS_KEY_DATA_NAME_DEV_PATH, "w"); |
109 | if (dev_fp == NULL) { |
110 | LOGE("%s, open %s ERROR(%s)!!\n", __FUNCTION__, |
111 | CS_KEY_DATA_NAME_DEV_PATH, strerror(errno)); |
112 | return -1; |
113 | } |
114 | |
115 | fprintf(dev_fp, "%s", key_name); |
116 | |
117 | fclose(dev_fp); |
118 | dev_fp = NULL; |
119 | |
120 | dev_fp = fopen(CS_KEY_DATA_READ_DEV_PATH, "r"); |
121 | if (dev_fp == NULL) { |
122 | LOGE("%s, open %s ERROR(%s)!!\n", __FUNCTION__, |
123 | CS_KEY_DATA_READ_DEV_PATH, strerror(errno)); |
124 | return -1; |
125 | } |
126 | |
127 | fscanf(dev_fp, "%s", data_buf); |
128 | |
129 | rd_cnt = strlen((char *)data_buf); |
130 | |
131 | fclose(dev_fp); |
132 | dev_fp = NULL; |
133 | |
134 | return rd_cnt; |
135 | } |
136 | |
137 | int WriteKeyData(const char *key_name, int wr_size, char data_buf[]) |
138 | { |
139 | FILE *dev_fp = NULL; |
140 | int wr_cnt = 0; |
141 | |
142 | dev_fp = fopen(CS_KEY_DATA_NAME_DEV_PATH, "w"); |
143 | if (dev_fp == NULL) { |
144 | LOGE("%s, open %s ERROR(%s)!!\n", __FUNCTION__, |
145 | CS_KEY_DATA_NAME_DEV_PATH, strerror(errno)); |
146 | return -1; |
147 | } |
148 | |
149 | fprintf(dev_fp, "%s", key_name); |
150 | |
151 | fclose(dev_fp); |
152 | dev_fp = NULL; |
153 | |
154 | dev_fp = fopen(CS_KEY_DATA_WRITE_DEV_PATH, "w"); |
155 | if (dev_fp == NULL) { |
156 | LOGE("%s, open %s ERROR(%s)!!\n", __FUNCTION__, |
157 | CS_KEY_DATA_WRITE_DEV_PATH, strerror(errno)); |
158 | return -1; |
159 | } |
160 | |
161 | wr_cnt = fwrite(data_buf, 1, wr_size, dev_fp); |
162 | |
163 | fclose(dev_fp); |
164 | dev_fp = NULL; |
165 | |
166 | return wr_cnt; |
167 | } |
168 | |
169 | int KeyData_GetMacAddressDataLen() |
170 | { |
171 | return CC_MAC_LEN; |
172 | } |
173 | |
174 | int KeyData_ReadMacAddress(unsigned char data_buf[]) |
175 | { |
176 | int i = 0, rd_size = 0; |
177 | int data_i_buf[CC_MAC_LEN] = { 0, 0, 0, 0, 0, 0 }; |
178 | unsigned char rd_buf[128] = { 0 }; |
179 | unsigned char tmp_buf[128] = { 0 }; |
180 | |
181 | memset((void *)rd_buf, 0 , 128); |
182 | rd_size = ReadKeyData(CS_MAC_KEY_NAME, rd_buf); |
183 | LOGD("%s, rd_size = %d\n", __FUNCTION__, rd_size); |
184 | |
185 | #if ANDROID_PLATFORM_SDK_VERSION == 19 |
186 | memcpy((void *)tmp_buf, (void *)rd_buf, 128); |
187 | rd_size = TransStringToHex(rd_size, (char *)rd_buf, tmp_buf); |
188 | #endif |
189 | |
190 | #if ANDROID_PLATFORM_SDK_VERSION >= 21 |
191 | memcpy((void *)tmp_buf, (void *)rd_buf, 128); |
192 | #endif |
193 | |
194 | if (rd_size == 17) { |
195 | sscanf((char *) tmp_buf, "%02x:%02x:%02x:%02x:%02x:%02x", |
196 | &data_i_buf[0], &data_i_buf[1], &data_i_buf[2], &data_i_buf[3], |
197 | &data_i_buf[4], &data_i_buf[5]); |
198 | for (i = 0; i < CC_MAC_LEN; i++) { |
199 | data_buf[i] = data_i_buf[i] & 0xFF; |
200 | } |
201 | |
202 | return KeyData_GetMacAddressDataLen(); |
203 | } |
204 | |
205 | return 0; |
206 | } |
207 | |
208 | int KeyData_SaveMacAddress(unsigned char data_buf[]) |
209 | { |
210 | int tmp_ret = 0, wr_size = 0; |
211 | unsigned char hex_buf[128] = { 0 }; |
212 | char tmp_buf[128] = { 0 }; |
213 | |
214 | sprintf((char *) hex_buf, "%02x:%02x:%02x:%02x:%02x:%02x", data_buf[0], |
215 | data_buf[1], data_buf[2], data_buf[3], data_buf[4], data_buf[5]); |
216 | |
217 | #if ANDROID_PLATFORM_SDK_VERSION == 19 |
218 | memset((void *)tmp_buf, 0, 128); |
219 | TransToHexString(strlen((char *) hex_buf), tmp_buf, hex_buf); |
220 | #endif |
221 | |
222 | #if ANDROID_PLATFORM_SDK_VERSION >= 21 |
223 | memset((void *)tmp_buf, 0, 128); |
224 | memcpy(tmp_buf, (const char *)hex_buf, strlen((char *) hex_buf)); |
225 | #endif |
226 | |
227 | wr_size = strlen(tmp_buf); |
228 | tmp_ret = WriteKeyData(CS_MAC_KEY_NAME, wr_size, tmp_buf); |
229 | if (tmp_ret != wr_size) { |
230 | return -1; |
231 | } |
232 | |
233 | CreateMacAddressStartWorkThread(); |
234 | |
235 | return 0; |
236 | } |
237 | |
238 | static int gSSMBarCodeLen = -1; |
239 | int KeyData_GetBarCodeDataLen() |
240 | { |
241 | const char *config_value; |
242 | |
243 | if (gSSMBarCodeLen <= 0) { |
244 | config_value = config_get_str(CFG_SECTION_TV, CS_BARCODE_LEN_CFG, "null"); |
245 | if (strcmp(config_value, "null") == 0) { |
246 | gSSMBarCodeLen = 32; |
247 | } else { |
248 | gSSMBarCodeLen = strtol(config_value, NULL, 10); |
249 | } |
250 | } |
251 | |
252 | return gSSMBarCodeLen; |
253 | } |
254 | |
255 | int KeyData_ReadBarCode(unsigned char data_buf[]) |
256 | { |
257 | int rd_size = 0, tmp_len = 0; |
258 | unsigned char rd_buf[CC_MAX_KEY_DATA_SIZE] = { 0 }; |
259 | |
260 | tmp_len = KeyData_GetBarCodeDataLen(); |
261 | rd_size = ReadKeyData(CS_BARCODE_KEY_NAME, rd_buf); |
262 | LOGD("%s, rd_size = %d\n", __FUNCTION__, rd_size); |
263 | |
264 | #if ANDROID_PLATFORM_SDK_VERSION == 19 |
265 | unsigned char tmp_buf[CC_MAX_KEY_DATA_SIZE] = { 0 }; |
266 | |
267 | memcpy((void *)tmp_buf, (void *)rd_buf, CC_MAX_KEY_DATA_SIZE); |
268 | rd_size = TransStringToHex(rd_size, (char *)rd_buf, tmp_buf); |
269 | |
270 | if (rd_size == tmp_len) { |
271 | memcpy(data_buf, tmp_buf, rd_size); |
272 | return rd_size; |
273 | } |
274 | #endif |
275 | |
276 | #if ANDROID_PLATFORM_SDK_VERSION >= 21 |
277 | if (rd_size == tmp_len) { |
278 | memcpy(data_buf, rd_buf, rd_size); |
279 | return rd_size; |
280 | } |
281 | #endif |
282 | |
283 | return 0; |
284 | } |
285 | |
286 | int KeyData_SaveBarCode(unsigned char data_buf[]) |
287 | { |
288 | int tmp_len = 0, wr_size = 0; |
289 | char tmp_buf[CC_MAX_KEY_DATA_SIZE] = { 0 }; |
290 | |
291 | tmp_len = KeyData_GetBarCodeDataLen(); |
292 | |
293 | #if ANDROID_PLATFORM_SDK_VERSION == 19 |
294 | memset((void *)tmp_buf, 0, CC_MAX_KEY_DATA_SIZE); |
295 | TransToHexString(tmp_len, tmp_buf, data_buf); |
296 | #endif |
297 | |
298 | #if ANDROID_PLATFORM_SDK_VERSION >= 21 |
299 | memset((void *)tmp_buf, 0, CC_MAX_KEY_DATA_SIZE); |
300 | memcpy(tmp_buf, (const char *)data_buf, strlen((char *) data_buf)); |
301 | #endif |
302 | |
303 | wr_size = strlen(tmp_buf); |
304 | tmp_len = WriteKeyData(CS_BARCODE_KEY_NAME, wr_size, tmp_buf); |
305 | if (tmp_len != wr_size) { |
306 | return -1; |
307 | } |
308 | |
309 | return 0; |
310 | } |
311 | |
312 | int SSMReadHDCPKey(unsigned char hdcp_key_buf[]) |
313 | { |
314 | int tmp_ret = 0, rd_size = 0; |
315 | unsigned char rd_buf[CC_MAX_KEY_DATA_SIZE] = { 0 }; |
316 | unsigned char tmp_buf[CC_MAX_KEY_DATA_SIZE] = { 0 }; |
317 | |
318 | tmp_ret = GetHDCPKeyFromFile(0, CC_HDCP_KEY_TOTAL_SIZE, hdcp_key_buf); |
319 | if (tmp_ret < 0) { |
320 | rd_size = ReadKeyData(CS_RX_HDCP_KEY_NAME, rd_buf); |
321 | LOGD("%s, rd_size = %d\n", __FUNCTION__, rd_size); |
322 | |
323 | memcpy((void *)tmp_buf, (void *)rd_buf, CC_MAX_KEY_DATA_SIZE); |
324 | rd_size = TransStringToHex(rd_size, (char *)rd_buf, tmp_buf); |
325 | |
326 | if (rd_size == CC_HDCP_KEY_TOTAL_SIZE) { |
327 | memcpy(hdcp_key_buf, tmp_buf, CC_HDCP_KEY_TOTAL_SIZE); |
328 | return rd_size; |
329 | } |
330 | |
331 | return 0; |
332 | } |
333 | |
334 | return CC_HDCP_KEY_TOTAL_SIZE; |
335 | } |
336 | |
337 | |
338 | |
339 | int SSMSaveHDCPKey(unsigned char hdcp_key_buf[]) |
340 | { |
341 | int tmp_ret = 0, wr_size = 0; |
342 | char tmp_buf[CC_MAX_KEY_DATA_SIZE] = { 0 }; |
343 | |
344 | tmp_ret = SaveHDCPKeyToFile(0, CC_HDCP_KEY_TOTAL_SIZE, hdcp_key_buf); |
345 | if (tmp_ret < 0) { |
346 | memset((void *)tmp_buf, 0, CC_MAX_KEY_DATA_SIZE); |
347 | TransToHexString(CC_HDCP_KEY_TOTAL_SIZE, tmp_buf, hdcp_key_buf); |
348 | |
349 | wr_size = strlen(tmp_buf); |
350 | tmp_ret = WriteKeyData(CS_RX_HDCP_KEY_NAME, wr_size, tmp_buf); |
351 | if (tmp_ret != wr_size) { |
352 | tmp_ret = -1; |
353 | } else { |
354 | tmp_ret = 0; |
355 | } |
356 | } |
357 | |
358 | return tmp_ret; |
359 | } |
360 | |
361 | int SSMSetHDCPKey() |
362 | { |
363 | |
364 | int i = 0; |
365 | unsigned char hdcp_key_buf[CC_HDCP_KEY_TOTAL_SIZE]; |
366 | |
367 | if (GetSSMHandleHDCPKeyEnableCFG() == 1) { |
368 | if (GetSSMHandleHDCPKeyDemoEnableCFG() == 1) { |
369 | return SSMSetDefaultHDCPKey(hdcp_key_buf); |
370 | } else { |
371 | if (SSMReadHDCPKey(hdcp_key_buf) == CC_HDCP_KEY_TOTAL_SIZE) { |
372 | LOGD("%s, using ssm's hdcp key.\n", __FUNCTION__); |
373 | return RealHandleHDCPKey(hdcp_key_buf); |
374 | } |
375 | } |
376 | } |
377 | |
378 | return -1; |
379 | } |
380 | |
381 | int SSMRefreshHDCPKey() |
382 | { |
383 | int ret = -1; |
384 | ret = SSMSetHDCPKey(); |
385 | system ( "/system/bin/dec" ); |
386 | return ret; |
387 | } |
388 | |
389 | int SSMGetHDCPKeyDataLen() |
390 | { |
391 | return CC_HDCP_KEY_TOTAL_SIZE; |
392 | } |
393 | |
394 | //hdmi edid |
395 | int SSMSetHDMIEdid(int port) |
396 | { |
397 | int i = 0; |
398 | unsigned char customer_hdmi_edid_buf[CC_CUSTOMER_HDMI_EDID_TOTAL_SIZE]; |
399 | unsigned char hdmi_edid_buf[SSM_HDMI_EDID_SIZE]; |
400 | |
401 | if (port < 1 && port > SSM_HDMI_PORT_MAX) { |
402 | LOGD("%s, hdmi port error.%d\n", __FUNCTION__, port); |
403 | return -1; |
404 | } |
405 | |
406 | if (GetSSMHandleHDMIEdidByCustomerEnableCFG() == 1) { |
407 | if (SSMReadHDMIEdid(port, hdmi_edid_buf) == 0) { |
408 | LOGD("%s, using ssm's hdmi edid.\n", __FUNCTION__); |
409 | LOGD("%s, begin to write hdmi edid:0x%x, 0x%x, 0x%x, 0x%x.\n", |
410 | __FUNCTION__, hdmi_edid_buf[8], hdmi_edid_buf[9], |
411 | hdmi_edid_buf[10], hdmi_edid_buf[255]); |
412 | if ( AppendEdidPrefixCode(customer_hdmi_edid_buf, hdmi_edid_buf) == 0 ) |
413 | return RealHandleHDMIEdid(customer_hdmi_edid_buf); |
414 | } |
415 | } |
416 | |
417 | return -1; |
418 | } |
419 | |
420 | int SSMReadHDMIEdid(int port, unsigned char hdmi_edid_buf[]) |
421 | { |
422 | int tmp_ret = 0; |
423 | LOGD("%s, read hdmi edid from bin file.\n", __FUNCTION__); |
424 | tmp_ret = GetHDMIEdidFromFile(0, SSM_HDMI_EDID_SIZE, port, hdmi_edid_buf); |
425 | if (tmp_ret < 0) { |
426 | LOGD("%s, read hdmi edid error.\n", __FUNCTION__); |
427 | } else { |
428 | LOGD("%s, 0x%x, 0x%x, 0x%x, 0x%x.\n", __FUNCTION__, hdmi_edid_buf[8], |
429 | hdmi_edid_buf[9], hdmi_edid_buf[10], hdmi_edid_buf[255]); |
430 | } |
431 | return tmp_ret; |
432 | } |
433 | |
434 | int KeyData_SaveProjectID(int rw_val) |
435 | { |
436 | int tmp_ret = 0, wr_size = 0; |
437 | char tmp_buf[64] = { 0 }; |
438 | |
439 | sprintf(tmp_buf, "%08X", rw_val); |
440 | |
441 | wr_size = strlen(tmp_buf); |
442 | tmp_ret = WriteKeyData(CS_PROJECT_ID_KEY_NAME, wr_size, tmp_buf); |
443 | if (tmp_ret != wr_size) { |
444 | return -1; |
445 | } |
446 | |
447 | return 0; |
448 | } |
449 | |
450 | int KeyData_ReadProjectID() |
451 | { |
452 | int rd_size = 0, tmp_val = 0; |
453 | unsigned char tmp_buf[64] = { 0 }; |
454 | |
455 | rd_size = ReadKeyData(CS_PROJECT_ID_KEY_NAME, tmp_buf); |
456 | LOGD("%s, rd_size = %d\n", __FUNCTION__, rd_size); |
457 | if (rd_size == 4) { |
458 | tmp_val = 0; |
459 | tmp_val |= tmp_buf[0] << 24; |
460 | tmp_val |= tmp_buf[1] << 16; |
461 | tmp_val |= tmp_buf[2] << 8; |
462 | tmp_val |= tmp_buf[3] << 0; |
463 | } |
464 | |
465 | return tmp_val; |
466 | } |
467 | |
468 | int SSMSaveRGBOGOValue(int offset, int size, unsigned char data_buf[]) |
469 | { |
470 | return SaveRGBOGOToFile(offset, size, data_buf); |
471 | } |
472 | |
473 | int SSMReadRGBOGOValue(int offset, int size, unsigned char data_buf[]) |
474 | { |
475 | return GetRGBOGOFromFile(offset, size, data_buf); |
476 | } |
477 | |
478 | int SSMSaveAudioNoLinePoints(int offset, int size, unsigned char tmp_buf[]) |
479 | { |
480 | return SaveAudioNoLinePointsDataToFile(offset, size, tmp_buf); |
481 | } |
482 | |
483 | int SSMReadAudioNoLinePoints(int offset, int size, unsigned char tmp_buf[]) |
484 | { |
485 | return GetAudioNoLinePointsDataFromFile(offset, size, tmp_buf); |
486 | } |
487 | |
488 | /**************************** start mac address static functions ****************************/ |
489 | #define CC_ERR_THREAD_ID (0) |
490 | |
491 | static pthread_t mMacAddressStartWorkThreadID = CC_ERR_THREAD_ID; |
492 | |
493 | static volatile unsigned int mMacAddressLow = -1; |
494 | static volatile unsigned int mMacAddressHigh = -1; |
495 | static volatile int mMacAddressStartWorkThreadExecFlag = -1; |
496 | static volatile int mMacAddressStartWorkThreadTurnOnFlag = -1; |
497 | |
498 | static pthread_mutex_t mac_address_low_mutex = PTHREAD_MUTEX_INITIALIZER; |
499 | static pthread_mutex_t mac_address_high_mutex = PTHREAD_MUTEX_INITIALIZER; |
500 | static pthread_mutex_t mac_address_exec_mutex = PTHREAD_MUTEX_INITIALIZER; |
501 | static pthread_mutex_t mac_address_turnon_mutex = PTHREAD_MUTEX_INITIALIZER; |
502 | |
503 | static int GetSSMMacAddressStartWorkEnableCFG() |
504 | { |
505 | const char *config_value; |
506 | |
507 | config_value = config_get_str(CFG_SECTION_TV, CS_MAC_ADDRESS_STARTWRK_EN_CFG, "null"); |
508 | if (strcmp(config_value, "null") == 0) { |
509 | LOGD( |
510 | "%s, get config is \"%s\", return 0 to not enable mac address start work.\n", |
511 | __FUNCTION__, config_value); |
512 | return 0; |
513 | } |
514 | |
515 | return strtoul(config_value, NULL, 10); |
516 | } |
517 | |
518 | static unsigned int SetMacAddressLow(unsigned int low_val) |
519 | { |
520 | unsigned int tmp_val; |
521 | |
522 | pthread_mutex_lock(&mac_address_low_mutex); |
523 | |
524 | tmp_val = mMacAddressLow; |
525 | |
526 | mMacAddressLow = low_val; |
527 | |
528 | pthread_mutex_unlock(&mac_address_low_mutex); |
529 | |
530 | return tmp_val; |
531 | } |
532 | |
533 | static unsigned int GetMacAddressLow() |
534 | { |
535 | unsigned int tmp_val = 0; |
536 | |
537 | pthread_mutex_lock(&mac_address_low_mutex); |
538 | |
539 | tmp_val = mMacAddressLow; |
540 | |
541 | pthread_mutex_unlock(&mac_address_low_mutex); |
542 | |
543 | return tmp_val; |
544 | } |
545 | |
546 | static unsigned int SetMacAddressHigh(unsigned int high_val) |
547 | { |
548 | unsigned int tmp_val; |
549 | |
550 | pthread_mutex_lock(&mac_address_high_mutex); |
551 | |
552 | tmp_val = mMacAddressHigh; |
553 | |
554 | mMacAddressHigh = high_val; |
555 | |
556 | pthread_mutex_unlock(&mac_address_high_mutex); |
557 | |
558 | return tmp_val; |
559 | } |
560 | |
561 | static unsigned int GetMacAddressHigh() |
562 | { |
563 | int tmp_val = 0; |
564 | |
565 | pthread_mutex_lock(&mac_address_high_mutex); |
566 | |
567 | tmp_val = mMacAddressHigh; |
568 | |
569 | pthread_mutex_unlock(&mac_address_high_mutex); |
570 | |
571 | return tmp_val; |
572 | } |
573 | |
574 | static int SetMacAddressStartWorkThreadExecFlag(int tmp_flag) |
575 | { |
576 | int tmp_val; |
577 | |
578 | pthread_mutex_lock(&mac_address_exec_mutex); |
579 | |
580 | tmp_val = mMacAddressStartWorkThreadExecFlag; |
581 | |
582 | mMacAddressStartWorkThreadExecFlag = tmp_flag; |
583 | |
584 | pthread_mutex_unlock(&mac_address_exec_mutex); |
585 | |
586 | return tmp_val; |
587 | } |
588 | |
589 | static int GetMacAddressStartWorkThreadExecFlag() |
590 | { |
591 | int tmp_val = 0; |
592 | |
593 | pthread_mutex_lock(&mac_address_exec_mutex); |
594 | |
595 | tmp_val = mMacAddressStartWorkThreadExecFlag; |
596 | |
597 | pthread_mutex_unlock(&mac_address_exec_mutex); |
598 | |
599 | return tmp_val; |
600 | } |
601 | |
602 | static int SetMacAddressStartWorkThreadTurnOnFlag(int tmp_flag) |
603 | { |
604 | int tmp_val; |
605 | |
606 | pthread_mutex_lock(&mac_address_turnon_mutex); |
607 | |
608 | tmp_val = mMacAddressStartWorkThreadTurnOnFlag; |
609 | |
610 | mMacAddressStartWorkThreadTurnOnFlag = tmp_flag; |
611 | |
612 | pthread_mutex_unlock(&mac_address_turnon_mutex); |
613 | |
614 | return tmp_val; |
615 | } |
616 | |
617 | static int GetMacAddressStartWorkThreadTurnOnFlag() |
618 | { |
619 | int tmp_val = 0; |
620 | |
621 | pthread_mutex_lock(&mac_address_turnon_mutex); |
622 | |
623 | tmp_val = mMacAddressStartWorkThreadTurnOnFlag; |
624 | |
625 | pthread_mutex_unlock(&mac_address_turnon_mutex); |
626 | |
627 | return tmp_val; |
628 | } |
629 | |
630 | static void *SSMMacAddressStartWorkMainApp(void *data) |
631 | { |
632 | unsigned int curMacAddrLow = 0, curMacAddrHigh = 0; |
633 | int p_status; |
634 | char ssm_addr_str[128]; |
635 | const char *iname = "eth0"; |
636 | pid_t pid; |
637 | |
638 | LOGD("%s, entering...\n", __FUNCTION__); |
639 | |
640 | if (GetSSMMacAddressStartWorkEnableCFG() == 0) { |
641 | LOGE("%s, ssm mac address start work is not enable.\n", CFG_SECTION_TV); |
642 | return NULL; |
643 | } |
644 | |
645 | curMacAddrLow = GetMacAddressLow(); |
646 | curMacAddrHigh = GetMacAddressHigh(); |
647 | |
648 | while (GetMacAddressStartWorkThreadTurnOnFlag() == 1) { |
649 | pid = fork(); |
650 | if (pid == 0) { |
651 | if (execl("/system/bin/stop", "stop_eth_dhcpcd", "eth_dhcpcd", NULL) |
652 | < 0) { |
653 | _exit(-1); |
654 | } |
655 | _exit(0); |
656 | } |
657 | waitpid(pid, &p_status, 0); |
658 | |
659 | ifc_init(); |
660 | |
661 | ifc_down(iname); |
662 | |
663 | sprintf(ssm_addr_str, "%02x:%02x:%02x:%02x:%02x:%02x", |
664 | ((curMacAddrLow >> 0) & 0xFF), ((curMacAddrLow >> 8) & 0xFF), |
665 | ((curMacAddrLow >> 16) & 0xFF), ((curMacAddrLow >> 24) & 0xFF), |
666 | ((curMacAddrHigh >> 0) & 0xFF), ((curMacAddrHigh >> 8) & 0xFF)); |
667 | struct ether_addr *addr = ether_aton(ssm_addr_str); |
668 | if (addr) { |
669 | ifc_set_hwaddr(iname, addr->ether_addr_octet); |
670 | } |
671 | |
672 | ifc_up(iname); |
673 | |
674 | ifc_close(); |
675 | |
676 | if (curMacAddrLow == GetMacAddressLow() |
677 | && curMacAddrHigh == GetMacAddressHigh()) { |
678 | break; |
679 | } |
680 | |
681 | curMacAddrLow = GetMacAddressLow(); |
682 | curMacAddrHigh = GetMacAddressHigh(); |
683 | } |
684 | |
685 | return NULL; |
686 | } |
687 | |
688 | static void *SSMMacAddressStartWorkThreadMain(void *data) |
689 | { |
690 | void *tmp_ret = NULL; |
691 | |
692 | SetMacAddressStartWorkThreadExecFlag(1); |
693 | |
694 | tmp_ret = SSMMacAddressStartWorkMainApp(NULL); |
695 | |
696 | SetMacAddressStartWorkThreadExecFlag(0); |
697 | |
698 | return tmp_ret; |
699 | } |
700 | |
701 | static int KillMacAddressStartWorkThread() |
702 | { |
703 | int i = 0, tmp_timeout_count = 600; |
704 | |
705 | SetMacAddressStartWorkThreadTurnOnFlag(0); |
706 | while (1) { |
707 | if (GetMacAddressStartWorkThreadExecFlag() == 0) { |
708 | break; |
709 | } |
710 | |
711 | if (i >= tmp_timeout_count) { |
712 | break; |
713 | } |
714 | |
715 | i++; |
716 | |
717 | usleep(100 * 1000); |
718 | } |
719 | |
720 | if (i == tmp_timeout_count) { |
721 | LOGE( |
722 | "%s, we have try %d times, but the mac address start work thread's exec flag is still(%d)!!!\n", |
723 | CFG_SECTION_TV, tmp_timeout_count, |
724 | GetMacAddressStartWorkThreadExecFlag()); |
725 | return -1; |
726 | } |
727 | |
728 | pthread_join(mMacAddressStartWorkThreadID, NULL); |
729 | mMacAddressStartWorkThreadID = CC_ERR_THREAD_ID; |
730 | |
731 | LOGD("%s, kill the mac address start work thread sucess.\n", __FUNCTION__); |
732 | |
733 | return 0; |
734 | } |
735 | |
736 | int CreateMacAddressStartWorkThread() |
737 | { |
738 | unsigned int macAddrLow = 0, macAddrHigh = 0; |
739 | pthread_attr_t attr; |
740 | struct sched_param param; |
741 | unsigned char ssm_addr_buf[16] = { 0, 0, 0, 0, 0, 0 }; |
742 | |
743 | if (KeyData_ReadMacAddress(ssm_addr_buf) < 0) { |
744 | return -1; |
745 | } |
746 | |
747 | macAddrLow = 0; |
748 | macAddrLow |= ((ssm_addr_buf[0] & 0xFF) << 0); |
749 | macAddrLow |= ((ssm_addr_buf[1] & 0xFF) << 8); |
750 | macAddrLow |= ((ssm_addr_buf[2] & 0xFF) << 16); |
751 | macAddrLow |= ((ssm_addr_buf[3] & 0xFF) << 24); |
752 | |
753 | macAddrHigh = 0; |
754 | macAddrHigh |= ((ssm_addr_buf[4] & 0xFF) << 0); |
755 | macAddrHigh |= ((ssm_addr_buf[5] & 0xFF) << 8); |
756 | |
757 | if (mMacAddressStartWorkThreadID != CC_ERR_THREAD_ID) { |
758 | if (GetMacAddressStartWorkThreadExecFlag() == 1) { |
759 | SetMacAddressLow(macAddrLow); |
760 | SetMacAddressHigh(macAddrHigh); |
761 | return 0; |
762 | } else { |
763 | KillMacAddressStartWorkThread(); |
764 | } |
765 | } |
766 | |
767 | SetMacAddressLow(macAddrLow); |
768 | SetMacAddressHigh(macAddrHigh); |
769 | SetMacAddressStartWorkThreadTurnOnFlag(1); |
770 | |
771 | pthread_attr_init(&attr); |
772 | pthread_attr_setschedpolicy(&attr, SCHED_RR); |
773 | param.sched_priority = 20; |
774 | pthread_attr_setschedparam(&attr, ¶m); |
775 | |
776 | if (pthread_create(&mMacAddressStartWorkThreadID, &attr, |
777 | SSMMacAddressStartWorkThreadMain, NULL) < 0) { |
778 | pthread_attr_destroy(&attr); |
779 | mMacAddressStartWorkThreadID = CC_ERR_THREAD_ID; |
780 | return -1; |
781 | } |
782 | |
783 | pthread_attr_destroy(&attr); |
784 | |
785 | LOGD("%s, create channel select thread sucess.\n", __FUNCTION__); |
786 | |
787 | return 0; |
788 | } |
789 | /**************************** end mac address static functions ****************************/ |
790 | |
791 | /**************************** start hdcp key static functions ****************************/ |
792 | int GetSSMHandleHDCPKeyEnableCFG() |
793 | { |
794 | const char *config_value; |
795 | |
796 | config_value = config_get_str(CFG_SECTION_TV, CS_HDCP_KEY_EN_CFG, "null"); |
797 | #if 0 |
798 | LOGD("%s, get \"%s\" is \"%s\".\n", __FUNCTION__, CS_HDCP_KEY_EN_CFG, |
799 | config_value); |
800 | #endif |
801 | if (strcmp(config_value, "null") == 0) { |
802 | LOGD( |
803 | "%s, get config \"%s\" is \"%s\", return 0 to not enable handle hdcp key.\n", |
804 | __FUNCTION__, CS_HDCP_KEY_EN_CFG, config_value); |
805 | return 0; |
806 | } |
807 | |
808 | return strtoul(config_value, NULL, 10); |
809 | } |
810 | |
811 | int GetSSMHandleHDCPKeyDemoEnableCFG() |
812 | { |
813 | const char *config_value; |
814 | |
815 | config_value = config_get_str(CFG_SECTION_TV, CS_HDCP_KEY_DEMO_EN_CFG, "null"); |
816 | #if 0 |
817 | LOGD("%s, get \"%s\" is \"%s\".\n", __FUNCTION__, CS_HDCP_KEY_DEMO_EN_CFG, |
818 | config_value); |
819 | #endif |
820 | if (strcmp(config_value, "null") == 0) { |
821 | LOGD( |
822 | "%s, get config \"%s\" is \"%s\", return 0 to not enable handle hdcp key demo.\n", |
823 | __FUNCTION__, CS_HDCP_KEY_DEMO_EN_CFG, config_value); |
824 | return 0; |
825 | } |
826 | |
827 | return strtoul(config_value, NULL, 10); |
828 | } |
829 | |
830 | |
831 | int SSMSetDefaultHDCPKey(unsigned char hdcp_key_buf[]) |
832 | { |
833 | int i = 0; |
834 | |
835 | for (i = 0; i < CC_HDCP_KEY_HEAD_SIZE; i++) { |
836 | hdcp_key_buf[i] = mHDCPKeyDefHeaderBuf[i]; |
837 | } |
838 | |
839 | for (i = 0; i < CC_HDCP_KEY_CONTENT_SIZE; i++) { |
840 | hdcp_key_buf[i + CC_HDCP_KEY_HEAD_SIZE] = mDefHDCPKeyContentBuf[i]; |
841 | } |
842 | |
843 | LOGD("%s, using default hdcp key.\n", __FUNCTION__); |
844 | |
845 | return RealHandleHDCPKey(hdcp_key_buf); |
846 | } |
847 | |
848 | int RealHandleHDCPKey(unsigned char hdcp_key_buf[]) |
849 | { |
850 | int i = 0, dev_fd = -1; |
851 | |
852 | if (hdcp_key_buf == NULL) { |
853 | return -1; |
854 | } |
855 | |
856 | dev_fd = open("/sys/class/hdmirx/hdmirx0/edid", O_RDWR); |
857 | if (dev_fd < 0) { |
858 | LOGE("%s, open edid file ERROR(%s)!!\n", CFG_SECTION_TV, strerror(errno)); |
859 | return -1; |
860 | } |
861 | |
862 | if (write(dev_fd, hdcp_key_buf, CC_HDCP_KEY_TOTAL_SIZE) < 0) { |
863 | close(dev_fd); |
864 | dev_fd = -1; |
865 | LOGE("%s, write edid file ERROR(%s)!!\n", CFG_SECTION_TV, strerror(errno)); |
866 | |
867 | return -1; |
868 | } |
869 | |
870 | close(dev_fd); |
871 | dev_fd = -1; |
872 | return 0; |
873 | } |
874 | |
875 | /**************************** end hdcp key static functions ****************************/ |
876 | |
877 | /**************************** start hdmi edid static functions ****************************/ |
878 | int GetSSMHandleHDMIEdidByCustomerEnableCFG() |
879 | { |
880 | const char *config_value; |
881 | |
882 | config_value = config_get_str(CFG_SECTION_TV, CS_HDMI_EDID_EN_CFG, "null"); |
883 | #if 0 |
884 | LOGD("%s, get \"%s\" is \"%s\".\n", __FUNCTION__, CS_HDMI_EDID_EN_CFG, |
885 | config_value); |
886 | #endif |
887 | if (strcmp(config_value, "null") == 0) { |
888 | LOGD( |
889 | "%s, get config \"%s\" is \"%s\", return 0 to not enable handle hdmi edid by customer.\n", |
890 | __FUNCTION__, CS_HDMI_EDID_EN_CFG, config_value); |
891 | return 0; |
892 | } |
893 | |
894 | return strtoul(config_value, NULL, 10); |
895 | } |
896 | int RealHandleHDMIEdid(unsigned char customer_hdmi_edid_buf[]) |
897 | { |
898 | int i = 0, dev_fd = -1; |
899 | |
900 | if (customer_hdmi_edid_buf == NULL) { |
901 | return -1; |
902 | } |
903 | |
904 | dev_fd = open("/sys/class/hdmirx/hdmirx0/edid", O_RDWR); |
905 | if (dev_fd < 0) { |
906 | LOGE("%s, open edid file ERROR(%s)!!\n", CFG_SECTION_TV, strerror(errno)); |
907 | return -1; |
908 | } |
909 | |
910 | if (write(dev_fd, customer_hdmi_edid_buf, CC_CUSTOMER_HDMI_EDID_TOTAL_SIZE) |
911 | < 0) { |
912 | close(dev_fd); |
913 | dev_fd = -1; |
914 | LOGE("%s, write edid file ERROR(%s)!!\n", CFG_SECTION_TV, strerror(errno)); |
915 | |
916 | return -1; |
917 | } |
918 | |
919 | close(dev_fd); |
920 | dev_fd = -1; |
921 | return 0; |
922 | } |
923 | |
924 | int AppendEdidPrefixCode(unsigned char customer_hdmi_edid_buf[], |
925 | unsigned char hdmi_edid_buf[]) |
926 | { |
927 | if (customer_hdmi_edid_buf == NULL || hdmi_edid_buf == NULL) { |
928 | LOGE("%s, Append hdmi edid's prefixCode ERROR(%s)!!\n", CFG_SECTION_TV, |
929 | strerror(errno)); |
930 | return -1; |
931 | } |
932 | memset(customer_hdmi_edid_buf, 0, |
933 | sizeof(char) * CC_CUSTOMER_HDMI_EDID_TOTAL_SIZE); |
934 | customer_hdmi_edid_buf[0] = 'E'; |
935 | customer_hdmi_edid_buf[1] = 'D'; |
936 | customer_hdmi_edid_buf[2] = 'I'; |
937 | customer_hdmi_edid_buf[3] = 'D'; |
938 | memcpy(customer_hdmi_edid_buf + 4, hdmi_edid_buf, |
939 | CC_CUSTOMER_HDMI_EDID_TOTAL_SIZE - 4); |
940 | /* |
941 | LOGD("%s, customer_hdmi_edid_buf: %c,%c,%c,%c,%x,%x,%x,%x.\n", __FUNCTION__, |
942 | customer_hdmi_edid_buf[0],customer_hdmi_edid_buf[1],customer_hdmi_edid_buf[2],customer_hdmi_edid_buf[3], |
943 | customer_hdmi_edid_buf[12],customer_hdmi_edid_buf[13],customer_hdmi_edid_buf[14],customer_hdmi_edid_buf[15]);*/ |
944 | /* |
945 | LOGD("%s, customer_hdmi_edid_buf: \n", __FUNCTION__); |
946 | int i, j; |
947 | for (i = 0; i < 16; i++) { |
948 | LOGD("[%2d] ", i); |
949 | for (j = 0; j < 16; j++) { |
950 | LOGD("0x%02lx, ", customer_hdmi_edid_buf[4 + (i*16 + j)]); |
951 | } |
952 | LOGD("\n"); |
953 | }*/ |
954 | return 0; |
955 | } |
956 | |
957 | /**************************** end hdmi edid static functions ****************************/ |
958 | |
959 | /**************************** start critical data op functions ****************************/ |
960 | #define CC_OP_TYPE_READ (0) |
961 | #define CC_OP_TYPE_SAVE (1) |
962 | #define CC_DATA_TYPE_CHAR (0) |
963 | #define CC_DATA_TYPE_INT (1) |
964 | |
965 | typedef int (*op_fun_ptr)(char *, int, int, unsigned char *); |
966 | |
967 | typedef struct tagRWDataInfo { |
968 | int op_type; |
969 | int data_type; |
970 | int max_size; |
971 | int rw_off; |
972 | int rw_size; |
973 | void *data_buf; |
974 | char *path_cfg_name; |
975 | char *off_cfg_name; |
976 | op_fun_ptr op_cb; |
977 | } RWDataInfo; |
978 | |
979 | static int GetFilePathCFG(char *key_str, char path_buf[]) |
980 | { |
981 | int tmp_ret = 0; |
982 | const char *cfg_value; |
983 | |
984 | path_buf[0] = '\0'; |
985 | cfg_value = config_get_str(CFG_SECTION_TV, key_str, ""); |
986 | strcpy(path_buf, cfg_value); |
987 | #if 0 |
988 | LOGD("%s, get \"%s\" is \"%s\".\n", CFG_SECTION_TV, key_str, path_buf); |
989 | #endif |
990 | return tmp_ret; |
991 | } |
992 | |
993 | static int GetFileOffsetCFG(char *key_str) |
994 | { |
995 | const char *cfg_value; |
996 | |
997 | cfg_value = config_get_str(CFG_SECTION_TV, key_str, "null"); |
998 | #if 0 |
999 | LOGD("%s, get \"%s\" is \"%s\".\n", CFG_SECTION_TV, key_str, cfg_value); |
1000 | #endif |
1001 | if (strcmp(cfg_value, "null") == 0) { |
1002 | LOGD("%s, get config \"%s\" is \"%s\", return 0 for default.\n", CFG_SECTION_TV, |
1003 | key_str, cfg_value); |
1004 | return 0; |
1005 | } |
1006 | |
1007 | return strtol(cfg_value, NULL, 10); |
1008 | } |
1009 | |
1010 | static int handleDataFilePath(char *file_name, int offset, int nsize, |
1011 | char file_path[]) |
1012 | { |
1013 | if (file_name == NULL) { |
1014 | LOGE("%s, file_name is NULL!!!\n", CFG_SECTION_TV); |
1015 | return -1; |
1016 | } |
1017 | |
1018 | return 0; |
1019 | } |
1020 | |
1021 | static int ReadDataFromFile(char *file_name, int offset, int nsize, |
1022 | unsigned char data_buf[]) |
1023 | { |
1024 | int device_fd = -1; |
1025 | int tmp_ret = 0; |
1026 | char *tmp_ptr = NULL; |
1027 | char file_path[512] = { '\0' }; |
1028 | |
1029 | if (data_buf == NULL) { |
1030 | LOGE("%s, data_buf is NULL!!!\n", CFG_SECTION_TV); |
1031 | return -1; |
1032 | } |
1033 | |
1034 | tmp_ret = handleDataFilePath(file_name, offset, nsize, file_path); |
1035 | if (tmp_ret < 0) { |
1036 | tmp_ptr = NULL; |
1037 | } else if (tmp_ret == 0) { |
1038 | tmp_ptr = file_name; |
1039 | } else if (tmp_ret == 1) { |
1040 | tmp_ptr = file_path; |
1041 | } |
1042 | |
1043 | if (tmp_ptr == NULL) { |
1044 | return -1; |
1045 | } |
1046 | |
1047 | device_fd = open(tmp_ptr, O_RDONLY); |
1048 | if (device_fd < 0) { |
1049 | LOGE("%s: open file \"%s\" error(%s).\n", CFG_SECTION_TV, file_name, |
1050 | strerror(errno)); |
1051 | return -1; |
1052 | } |
1053 | |
1054 | lseek(device_fd, offset, SEEK_SET); |
1055 | read(device_fd, data_buf, nsize); |
1056 | |
1057 | close(device_fd); |
1058 | device_fd = -1; |
1059 | |
1060 | return 0; |
1061 | } |
1062 | |
1063 | static int SaveDataToFile(char *file_name, int offset, int nsize, |
1064 | unsigned char data_buf[]) |
1065 | { |
1066 | int device_fd = -1; |
1067 | int i = 0, tmp_ret = 0; |
1068 | char *tmp_ptr = NULL; |
1069 | char file_path[512] = { '\0' }; |
1070 | |
1071 | if (data_buf == NULL) { |
1072 | LOGE("%s, data_buf is NULL!!!\n", CFG_SECTION_TV); |
1073 | return -1; |
1074 | } |
1075 | |
1076 | tmp_ret = handleDataFilePath(file_name, offset, nsize, file_path); |
1077 | if (tmp_ret < 0) { |
1078 | tmp_ptr = NULL; |
1079 | } else if (tmp_ret == 0) { |
1080 | tmp_ptr = file_name; |
1081 | } else if (tmp_ret == 1) { |
1082 | tmp_ptr = file_path; |
1083 | } |
1084 | |
1085 | if (tmp_ptr == NULL) { |
1086 | return -1; |
1087 | } |
1088 | |
1089 | device_fd = open(tmp_ptr, O_RDWR | O_SYNC); |
1090 | if (device_fd < 0) { |
1091 | LOGE("%s: open file \"%s\" error(%s).\n", CFG_SECTION_TV, file_name, |
1092 | strerror(errno)); |
1093 | return -1; |
1094 | } |
1095 | |
1096 | lseek(device_fd, offset, SEEK_SET); |
1097 | write(device_fd, data_buf, nsize); |
1098 | fsync(device_fd); |
1099 | |
1100 | close(device_fd); |
1101 | device_fd = -1; |
1102 | |
1103 | return 0; |
1104 | } |
1105 | |
1106 | static int RealRWData(RWDataInfo *data_info) |
1107 | { |
1108 | int i = 0, file_off = 0; |
1109 | char file_name[256] = { '\0' }; |
1110 | |
1111 | memset(file_name, '\0', 256); |
1112 | GetFilePathCFG(data_info->path_cfg_name, file_name); |
1113 | #if 0 |
1114 | LOGD("%s, file_name is %s.\n", __FUNCTION__, file_name); |
1115 | #endif |
1116 | if (strlen(file_name) == 0) { |
1117 | LOGE("%s, length of file_name is 0!!!\n", CFG_SECTION_TV); |
1118 | return -2; |
1119 | } |
1120 | |
1121 | if (data_info->rw_off < 0) { |
1122 | LOGE("%s, data_info->rw_off (%d) is less than 0!!!\n", CFG_SECTION_TV, |
1123 | data_info->rw_off); |
1124 | return -1; |
1125 | } |
1126 | |
1127 | if (data_info->rw_off + data_info->rw_size > data_info->max_size) { |
1128 | LOGE( |
1129 | "%s, data_info->rw_off + data_info->rw_size (%d) is more than data_info->max_size(%d) !!!\n", |
1130 | CFG_SECTION_TV, data_info->rw_off + data_info->rw_size, |
1131 | data_info->max_size); |
1132 | return -1; |
1133 | } |
1134 | |
1135 | file_off = GetFileOffsetCFG(data_info->off_cfg_name); |
1136 | if (file_off < 0) { |
1137 | LOGE("%s, file_off (%d) is less than 0!!!\n", CFG_SECTION_TV, file_off); |
1138 | return -1; |
1139 | } |
1140 | |
1141 | file_off += data_info->rw_off; |
1142 | |
1143 | if (data_info->op_cb(file_name, file_off, data_info->rw_size, |
1144 | (unsigned char *) data_info->data_buf) < 0) { |
1145 | return -1; |
1146 | } |
1147 | |
1148 | return 0; |
1149 | } |
1150 | |
1151 | static int HandleRWData(RWDataInfo *data_info) |
1152 | { |
1153 | int i = 0, tmp_ret = 0; |
1154 | int *tmp_iptr = NULL; |
1155 | unsigned char *tmp_cptr = NULL; |
1156 | RWDataInfo tmpInfo; |
1157 | |
1158 | if (data_info == NULL) { |
1159 | return -1; |
1160 | } |
1161 | |
1162 | tmpInfo = *data_info; |
1163 | |
1164 | if (data_info->data_type == CC_DATA_TYPE_INT) { |
1165 | tmp_cptr = new unsigned char[data_info->rw_size]; |
1166 | if (tmp_cptr != NULL) { |
1167 | tmpInfo.data_buf = tmp_cptr; |
1168 | |
1169 | if (tmpInfo.op_type == CC_OP_TYPE_SAVE) { |
1170 | tmp_iptr = (int *) data_info->data_buf; |
1171 | for (i = 0; i < data_info->rw_size; i++) { |
1172 | tmp_cptr[i] = tmp_iptr[i]; |
1173 | } |
1174 | |
1175 | tmp_ret |= RealRWData(&tmpInfo); |
1176 | } else { |
1177 | tmp_ret |= RealRWData(&tmpInfo); |
1178 | |
1179 | tmp_iptr = (int *) data_info->data_buf; |
1180 | for (i = 0; i < data_info->rw_size; i++) { |
1181 | tmp_iptr[i] = tmp_cptr[i]; |
1182 | } |
1183 | } |
1184 | |
1185 | delete tmp_cptr; |
1186 | tmp_cptr = NULL; |
1187 | |
1188 | return tmp_ret; |
1189 | } |
1190 | } |
1191 | |
1192 | return RealRWData(&tmpInfo); |
1193 | } |
1194 | |
1195 | int GetRGBOGOFromFile(int rd_off, int rd_size, |
1196 | unsigned char data_buf[]) |
1197 | { |
1198 | RWDataInfo tmpInfo; |
1199 | |
1200 | tmpInfo.op_type = CC_OP_TYPE_READ; |
1201 | tmpInfo.data_type = CC_DATA_TYPE_CHAR; |
1202 | tmpInfo.max_size = SSM_CR_RGBOGO_LEN + SSM_CR_RGBOGO_CHKSUM_LEN; |
1203 | tmpInfo.rw_off = rd_off; |
1204 | tmpInfo.rw_size = rd_size; |
1205 | tmpInfo.data_buf = data_buf; |
1206 | tmpInfo.path_cfg_name = (char *) CS_RGBOGO_FILE_PATH_CFG; |
1207 | tmpInfo.off_cfg_name = (char *) CS_RGBOGO_FILE_OFFSET_CFG; |
1208 | tmpInfo.op_cb = ReadDataFromFile; |
1209 | |
1210 | return HandleRWData(&tmpInfo); |
1211 | } |
1212 | |
1213 | int SaveRGBOGOToFile(int wr_off, int wr_size, unsigned char data_buf[]) |
1214 | { |
1215 | RWDataInfo tmpInfo; |
1216 | |
1217 | tmpInfo.op_type = CC_OP_TYPE_SAVE; |
1218 | tmpInfo.data_type = CC_DATA_TYPE_CHAR; |
1219 | tmpInfo.max_size = SSM_CR_RGBOGO_LEN + SSM_CR_RGBOGO_CHKSUM_LEN; |
1220 | tmpInfo.rw_off = wr_off; |
1221 | tmpInfo.rw_size = wr_size; |
1222 | tmpInfo.data_buf = data_buf; |
1223 | tmpInfo.path_cfg_name = (char *) CS_RGBOGO_FILE_PATH_CFG; |
1224 | tmpInfo.off_cfg_name = (char *) CS_RGBOGO_FILE_OFFSET_CFG; |
1225 | tmpInfo.op_cb = SaveDataToFile; |
1226 | |
1227 | return HandleRWData(&tmpInfo); |
1228 | } |
1229 | |
1230 | int GetAudioNoLinePointsDataFromFile(int rd_off, int rd_size, |
1231 | unsigned char data_buf[]) |
1232 | { |
1233 | RWDataInfo tmpInfo; |
1234 | |
1235 | tmpInfo.op_type = CC_OP_TYPE_READ; |
1236 | tmpInfo.data_type = CC_DATA_TYPE_CHAR; |
1237 | tmpInfo.max_size = 256; |
1238 | tmpInfo.rw_off = rd_off; |
1239 | tmpInfo.rw_size = rd_size; |
1240 | tmpInfo.data_buf = data_buf; |
1241 | tmpInfo.path_cfg_name = (char *) CS_AUDIO_NOLINEPOINTS_FILE_PATH_CFG; |
1242 | tmpInfo.off_cfg_name = (char *) CS_AUDIO_NOLINEPOINTS_FILE_OFFSET_CFG; |
1243 | tmpInfo.op_cb = ReadDataFromFile; |
1244 | |
1245 | return HandleRWData(&tmpInfo); |
1246 | } |
1247 | |
1248 | int SaveAudioNoLinePointsDataToFile(int wr_off, int wr_size, |
1249 | unsigned char data_buf[]) |
1250 | { |
1251 | RWDataInfo tmpInfo; |
1252 | |
1253 | tmpInfo.op_type = CC_OP_TYPE_SAVE; |
1254 | tmpInfo.data_type = CC_DATA_TYPE_CHAR; |
1255 | tmpInfo.max_size = 256; |
1256 | tmpInfo.rw_off = wr_off; |
1257 | tmpInfo.rw_size = wr_size; |
1258 | tmpInfo.data_buf = data_buf; |
1259 | tmpInfo.path_cfg_name = (char *) CS_AUDIO_NOLINEPOINTS_FILE_PATH_CFG; |
1260 | tmpInfo.off_cfg_name = (char *) CS_AUDIO_NOLINEPOINTS_FILE_OFFSET_CFG; |
1261 | tmpInfo.op_cb = SaveDataToFile; |
1262 | |
1263 | return HandleRWData(&tmpInfo); |
1264 | } |
1265 | |
1266 | int GetHDCPKeyFromFile(int rd_off, int rd_size, |
1267 | unsigned char data_buf[]) |
1268 | { |
1269 | RWDataInfo tmpInfo; |
1270 | |
1271 | tmpInfo.op_type = CC_OP_TYPE_READ; |
1272 | tmpInfo.data_type = CC_DATA_TYPE_CHAR; |
1273 | tmpInfo.max_size = CC_HDCP_KEY_TOTAL_SIZE; |
1274 | tmpInfo.rw_off = rd_off; |
1275 | tmpInfo.rw_size = rd_size; |
1276 | tmpInfo.data_buf = data_buf; |
1277 | tmpInfo.path_cfg_name = (char *) CS_HDCP_KEY_FILE_PATH_CFG; |
1278 | tmpInfo.off_cfg_name = (char *) CS_HDCP_KEY_FILE_OFFSET_CFG; |
1279 | tmpInfo.op_cb = ReadDataFromFile; |
1280 | |
1281 | return HandleRWData(&tmpInfo); |
1282 | } |
1283 | |
1284 | int SaveHDCPKeyToFile(int wr_off, int wr_size, |
1285 | unsigned char data_buf[]) |
1286 | { |
1287 | RWDataInfo tmpInfo; |
1288 | |
1289 | tmpInfo.op_type = CC_OP_TYPE_SAVE; |
1290 | tmpInfo.data_type = CC_DATA_TYPE_CHAR; |
1291 | tmpInfo.max_size = CC_HDCP_KEY_TOTAL_SIZE; |
1292 | tmpInfo.rw_off = wr_off; |
1293 | tmpInfo.rw_size = wr_size; |
1294 | tmpInfo.data_buf = data_buf; |
1295 | tmpInfo.path_cfg_name = (char *) CS_HDCP_KEY_FILE_PATH_CFG; |
1296 | tmpInfo.off_cfg_name = (char *) CS_HDCP_KEY_FILE_OFFSET_CFG; |
1297 | tmpInfo.op_cb = SaveDataToFile; |
1298 | |
1299 | return HandleRWData(&tmpInfo); |
1300 | } |
1301 | |
1302 | int GetHDMIEdidFromFile(int rd_off, int rd_size, int port, |
1303 | unsigned char data_buf[]) |
1304 | { |
1305 | RWDataInfo tmpInfo; |
1306 | |
1307 | tmpInfo.op_type = CC_OP_TYPE_READ; |
1308 | tmpInfo.data_type = CC_DATA_TYPE_CHAR; |
1309 | tmpInfo.max_size = SSM_HDMI_EDID_SIZE; |
1310 | tmpInfo.rw_off = rd_off; |
1311 | tmpInfo.rw_size = rd_size; |
1312 | tmpInfo.data_buf = data_buf; |
1313 | switch (port) { |
1314 | case 1: |
1315 | tmpInfo.path_cfg_name = (char *) CS_HDMI_PORT1_EDID_FILE_PATH_CFG; |
1316 | break; |
1317 | case 2: |
1318 | tmpInfo.path_cfg_name = (char *) CS_HDMI_PORT2_EDID_FILE_PATH_CFG; |
1319 | break; |
1320 | case 3: |
1321 | tmpInfo.path_cfg_name = (char *) CS_HDMI_PORT3_EDID_FILE_PATH_CFG; |
1322 | break; |
1323 | default: |
1324 | LOGE("%s, port is error, =%d\n", CFG_SECTION_TV, port); |
1325 | tmpInfo.path_cfg_name = (char *) CS_HDMI_EDID_FILE_PATH_CFG; |
1326 | break; |
1327 | } |
1328 | tmpInfo.off_cfg_name = (char *) CS_HDMI_EDID_FILE_OFFSET_CFG; |
1329 | tmpInfo.op_cb = ReadDataFromFile; |
1330 | |
1331 | return HandleRWData(&tmpInfo); |
1332 | } |
1333 | |
1334 | /**************************** end critical data op functions ****************************/ |
1335 |