1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * ELAN HID-I2C TouchScreen driver.
4 *
5 * Copyright (C) 2014 Elan Microelectronics Corporation.
6 *
7 * Author: Chuming Zhang <chuming.zhang@elanic.com.cn>
8 */
9
10 #include "elan_ts.h"
11 #include <asm/unaligned.h>
12
13 //define private data
14 //#define IAP_PORTION
15
16
17 uint8_t active_pen_fw[]= {
18 #include "MA50_HIDoverI2C_570B.cfg"
19 };
20 uint8_t passive_pen_fw[]= {
21 // #include "passive_pen.i"
22 };
23
24 const struct vendor_map g_vendor_map[]=
25 {
26 {0x2ae2, "fw_data", active_pen_fw, sizeof(active_pen_fw), 0x271F},
27 {0x2ae1, "passive_pen", passive_pen_fw, sizeof(passive_pen_fw), 0x271F},
28 };
29
30 //#define ELAN_FW_PAGESIZE (132)
31
get_hid_iap_ack(struct elan_ts_data * ts,uint8_t * cmd,int len,uint8_t * buf,int rlen)32 static int get_hid_iap_ack(struct elan_ts_data *ts, uint8_t *cmd, int len,uint8_t *buf, int rlen)
33 {
34 int err = 0;
35 const uint8_t ack_ok[2] = {0xaa,0xaa};
36 const uint8_t ack_rewrite[2] = {0x55,0x55};
37
38 err = ts->ops->send(cmd,len);
39 if (err != len) {
40 dev_err(&ts->client->dev, "[elan] write page finish command fauled\n");
41 return err;
42 }
43
44 err = ts->ops->poll();
45 if (err) {
46 dev_err(&ts->client->dev, "[elan] wait for int failed\n");
47 return err;
48 }
49
50 err = ts->ops->recv(buf,rlen);
51 dev_info(&ts->client->dev, "[elan]%s buf[4]:buf[5]= %x:%x\n",__func__, buf[4],buf[5]);
52 if ( err == rlen) {
53 if (memcmp(buf+4,ack_ok,sizeof(ack_ok)) == 0) {
54 dev_info(&ts->client->dev,"[elan] iap write page response ok\n");
55 return 0;
56 } else if (memcmp(buf+4, ack_rewrite, sizeof(ack_rewrite))) {
57 dev_err(&ts->client->dev, "[elan] iap rewrite page response\n");
58 return 1;
59 } else {
60 dev_err(&ts->client->dev, "[elan] iap ack error\n");
61 return -1;
62 }
63 } else {
64 dev_err(&ts->client->dev, "[elan] recv ack return value error\n");
65 return err;
66 }
67
68 return 0;
69 }
70
query_remark_id(struct elan_ts_data * ts)71 static int query_remark_id(struct elan_ts_data *ts)
72 {
73 int len = 0;
74 uint8_t remarkid[HID_CMD_LEN] = {0x04,0x00,0x23,0x00,0x03,0x00,0x06,0x96,0x80,0x1F,0x00,0x00,0x21};
75 uint8_t buf[67] = {0};
76 u16 remark_id = 0;
77
78 len = ts->ops->send(remarkid,sizeof(remarkid));
79 if ( len != sizeof(remarkid) ) {
80 dev_err(&ts->client->dev, "[elan]Send query remark id cmd failed!! len=%d",len);
81 return -EINVAL;
82 } else
83 dev_err(&ts->client->dev,"[elan]Remark id write successfully!");
84
85 msleep(5);
86
87 len = ts->ops->recv(buf, sizeof(buf));
88 if (len != sizeof(buf)) {
89 dev_err(&ts->client->dev, "[elan]Send Check Address Read Data error. len=%d", len);
90 return -EINVAL;
91 } else {
92 remark_id = (buf[7] << 8) | buf[8];
93 dev_err(&ts->client->dev, "[elan]Get Remark id = 0x%4x",remark_id);
94 return remark_id;
95 }
96 }
97
98
hid_fw_upgrade_init(struct elan_ts_data * ts)99 static int hid_fw_upgrade_init(struct elan_ts_data *ts)
100 {
101 int err = 0;
102 u16 remark_id;
103 const uint8_t flash_key[HID_CMD_LEN] = {0x04,0x00,0x23,0x00,0x03,0x00,0x04,0x54,0xc0,0xe1,0x5a};
104 const uint8_t check_addr[HID_CMD_LEN] = {0x04,0x00,0x23,0x00,0x03,0x00,0x01,0x10};
105 const uint8_t isp_cmd[HID_CMD_LEN] = {0x04,0x00,0x23,0x00,0x03,0x00,0x04,0x54,0x00,0x12,0x34};
106 uint8_t buf[67] = {0};
107 uint8_t response_addr = 0x20;
108
109 elan_ts_hw_reset(&ts->hw_info);
110 mdelay(300);
111
112 err = elan_ic_status(ts->client);
113 if (err == FORCED_UPGRADE)
114 ts->recover = FORCED_UPGRADE;
115 else if (err == COMPARE_UPGRADE)
116 ts->recover = COMPARE_UPGRADE;
117 else
118 ts->recover = UNKNOW_TYPE;
119
120 if (err != UNKNOW_TYPE) {
121 dev_err(&ts->client->dev, "[elan] %s bcl = 0x%02x\n", __func__,ts->fw_info.fw_bcl);
122 if (ts->fw_info.fw_bcl >= 0x60) {
123 remark_id = query_remark_id(ts);
124 if ( remark_id != ts->update_info.remark_id) {
125 dev_err(&ts->client->dev, "[elan]Remark id failed,exit update");
126 return err;
127 }
128 }
129 }
130
131 dev_err(&ts->client->dev, "[elan] %s get ic status = %d\n", __func__, err);
132 err = ts->ops->send(flash_key,sizeof(flash_key));
133 if ( err != sizeof(flash_key)) {
134 dev_err(&ts->client->dev, "[elan]send flash key failed ,exit update\n");
135 return err;
136 }
137
138 mdelay(20);
139
140 if (ts->recover == COMPARE_UPGRADE) {//normal mode
141 err = ts->ops->send(isp_cmd, sizeof(isp_cmd));
142 if ( err != sizeof(isp_cmd)) {
143 dev_err(&ts->client->dev, "[elan] send isp cmd failed, exit update\n");
144 return err;
145 }
146 }
147
148 mdelay(20);
149
150 err = ts->ops->send(check_addr, sizeof(check_addr));
151 if ( err != sizeof(check_addr)) {
152 dev_err(&ts->client->dev, "[elan] send check addr failed, exit update\n");
153 return err;
154 }
155
156 // mdelay(20);
157 ts->ops->poll();
158 err = ts->ops->recv(buf, sizeof(buf));
159 if ( err != sizeof(buf)) {
160 dev_err(&ts->client->dev, "[elan] recv check addr response failed\n");
161 return err;
162 }
163
164 dev_err(&ts->client->dev, "[elan] %s response_addr = 0x%02x, buf=0x%2x\n",__func__, response_addr, buf[4]);
165 if (memcmp(&buf[4], &response_addr, 1)) {
166 dev_err(&ts->client->dev, "[elan] response addr check failed,exit update\n");
167 return err;
168 } else {
169 dev_err(&ts->client->dev, "[elan] update init success\n");
170 err = 0;
171 }
172
173 return err;
174 }
175
176
hid_fw_upgrade_finshed(struct elan_ts_data * ts)177 static int hid_fw_upgrade_finshed(struct elan_ts_data *ts)
178 {
179 int ret = 0;
180 uint8_t upgrade_end[HID_CMD_LEN] = {0x04,0x00,0x23,0x00,0x03,0x1A};
181
182 ret = ts->ops->send(upgrade_end, sizeof(upgrade_end));
183 if (ret != sizeof(upgrade_end))
184 ret = -1;
185 else
186 ret = 0;
187
188 return ret;
189 }
190
Hid_Fw_Update(struct i2c_client * client)191 static int Hid_Fw_Update(struct i2c_client *client)
192 {
193 struct elan_ts_data *ts = i2c_get_clientdata(client);
194 struct elan_update_fw_info *update = &ts->update_info;
195 int wRemainLen = 0;
196 int wCopyLen = 0;
197 int wFwSize = update->FwSize;
198 int wCount = 0;
199 int wPayLoadLen = 0;
200 int qOffset = 0;
201 int qCmdLen = 9;
202 int err = 0;
203 int retry = 3;
204 uint8_t ack_buf[67] = {0x00};
205 uint8_t qIapPagefinishcmd[HID_CMD_LEN] = {0x04,0x00,0x23,0x00,0x03,0x22};
206 uint8_t qIapWriteCmd[HID_CMD_LEN] = {0x04,0x00,0x23,0x00,0x03,0x21,0x00,0x00,0x1c};
207
208 update_retry:
209
210 err = hid_fw_upgrade_init(ts);
211 if ( err ) {
212 dev_err(&ts->client->dev, "[elan] upgrade init failed\n");
213 if ((retry-- > 0))
214 goto update_retry;
215 else
216 return -1;
217 }
218
219 msleep(50);
220 dev_err(&ts->client->dev, "[elan]%s fw size = %d\n", __func__,wFwSize);
221 while(wFwSize) {
222 wRemainLen = MIN((update->FwSize - wCount),( IAP_FLASH_SIZE -( qOffset % IAP_FLASH_SIZE )));
223 wCopyLen = MIN(wRemainLen, HID_CMD_LEN - qCmdLen);
224
225 //dev_info(&ts->client->dev,"[elan]%s wRemainLen:wCopyLen = %d:%d\n", __func__,wRemainLen, wCopyLen);
226 memcpy(qIapWriteCmd+ IAP_CMD_HEADER_LEN, update->FwData + wCount, wCopyLen);
227 qCmdLen += wCopyLen;
228
229 wPayLoadLen = wCopyLen;
230
231 qIapWriteCmd[6] = qOffset >> 8;
232 qIapWriteCmd[7] = qOffset & 0xff;
233 qIapWriteCmd[8] = wPayLoadLen;
234
235 err = ts->ops->send(qIapWriteCmd, sizeof(qIapWriteCmd));
236 if ( err != sizeof(qIapWriteCmd)) {
237 dev_err(&ts->client->dev,"[elan]write %dbytes failed\n", wCopyLen);
238 if ( (retry--) > 0) {
239 qOffset = 0;
240 wFwSize = update->FwSize;
241 wCount = 0;
242 qCmdLen = IAP_CMD_HEADER_LEN;
243 goto update_retry;
244 } else
245 return -1;
246 }
247
248 qCmdLen = IAP_CMD_HEADER_LEN;
249 qOffset += wPayLoadLen;
250 wCount += wPayLoadLen;
251 wFwSize -= wPayLoadLen;
252
253 if( (qOffset % (IAP_FLASH_SIZE) == 0) ||( wCount == update->FwSize)) {
254 err = get_hid_iap_ack(ts,qIapPagefinishcmd,sizeof(qIapPagefinishcmd),ack_buf, sizeof(ack_buf));
255 if (err) {
256 dev_err(&ts->client->dev, "get iap ack failed\n");
257 if ( (retry--) > 0) {
258 wFwSize = update->FwSize;
259 wCount = 0;
260 qCmdLen = IAP_CMD_HEADER_LEN;
261 qOffset = 0;
262 goto update_retry;
263 } else
264 return -1;
265 } else
266 qOffset = 0;
267 }
268 }
269
270 err = hid_fw_upgrade_finshed(ts);
271 if (err) {
272 dev_err(&ts->client->dev,"[elan] fw upgrade finshed failed!!!\n");
273 return -1;
274 }
275
276 dev_err(&ts->client->dev,"[elan] fw upgrade success!!!\n");
277 return 0;
278
279 }
280
elan_fw_write_page(struct i2c_client * client,const void * page)281 static int elan_fw_write_page(struct i2c_client *client,
282 const void *page)
283 {
284 struct elan_ts_data *ts = i2c_get_clientdata(client);
285 const uint8_t ack_ok[] = { 0xaa, 0xaa };
286 uint8_t buf[2] = {0x00};
287 int retry;
288 int error;
289
290
291 for (retry = 0; retry < 5; retry++) {
292 error = ts->ops->send(page, FW_PAGE_SIZE);
293 if (error != FW_PAGE_SIZE) {
294 dev_err(&client->dev,
295 "IAP Write Page failed: %d\n", error);
296 continue;
297 }
298
299 error = ts->ops->recv(buf, sizeof(buf));
300 if (error != sizeof(buf)) {
301 dev_err(&client->dev,
302 "IAP Ack read failed: %d\n", error);
303 return error;
304 }
305
306 if (!memcmp(buf, ack_ok, sizeof(ack_ok)))
307 return 0;
308
309 error = -EIO;
310 dev_err(&client->dev,
311 "IAP Get Ack Error [%02x:%02x]\n",
312 buf[0], buf[1]);
313 }
314 return error;
315 }
316
317
Normal_Fw_Update(struct i2c_client * client)318 static int Normal_Fw_Update(struct i2c_client *client)
319 {
320 struct elan_ts_data *ts = i2c_get_clientdata(client);
321 struct elan_update_fw_info *update = &ts->update_info;
322 const uint8_t enter_iap[] = { 0x45, 0x49, 0x41, 0x50 };
323 // const uint8_t enter_isp[] = { 0x54, 0x00, 0x12, 0x34 };
324 const uint8_t iap_ack[] = { 0x55, 0xaa, 0x33, 0xcc };
325 uint8_t buf[4] = {0x00};
326 int page = 0;
327 int error;
328 uint8_t send_id;
329
330
331 elan_ts_hw_reset(&ts->hw_info);
332 msleep(20);
333 error = ts->ops->send(enter_iap, sizeof(enter_iap));
334 if (error != sizeof(enter_iap)) {
335 dev_err(&client->dev, "failed to enter IAP mode: %d\n", error);
336 return error;
337 }
338
339 msleep(20);
340
341 /* check IAP state */
342 error = ts->ops->recv(buf, sizeof(buf));
343 if (error != sizeof(buf)) {
344 dev_err(&client->dev,
345 "failed to read IAP acknowledgement: %d\n",
346 error);
347 return error;
348 }
349
350 if (memcmp(buf, iap_ack, sizeof(iap_ack))) {
351 dev_err(&client->dev,
352 "failed to enter IAP: %*ph (expected %*ph)\n",
353 (int)sizeof(buf), buf, (int)sizeof(iap_ack), iap_ack);
354 return -EIO;
355 }
356
357 dev_info(&client->dev, "successfully entered IAP mode");
358
359 /* send dummy byte */
360 send_id = client->addr;
361 error = ts->ops->send(&send_id, 1);
362 if (error != 1) {
363 dev_err(&client->dev, "sending dummy byte failed: %d\n",
364 error);
365 return error;
366 }
367
368 /*write page*/
369 for (page = 0; page < update->PageNum; page++) {
370
371 error = elan_fw_write_page(client,
372 update->FwData + page * FW_PAGE_SIZE);
373 if (error) {
374 dev_err(&client->dev,
375 "failed to write FW page %d: %d\n",
376 page, error);
377 return error;
378 }
379 }
380
381 msleep(300);
382
383 dev_info(&client->dev, "firmware update completed\n");
384
385 return 0;
386
387 }
388
elan_FW_Update(struct i2c_client * client)389 int elan_FW_Update(struct i2c_client *client)
390 {
391 int err = 0;
392 struct elan_ts_data *ts = i2c_get_clientdata(client);
393
394
395 if (ts->chip_type == HID_TYPE_PROTOCOL){
396 err = Hid_Fw_Update(client);
397 if (!err)
398 ts->recover = COMPARE_UPGRADE;
399
400 }
401 else if(ts->chip_type == NORMAL_TYPE_PROTOCOL)
402 err = Normal_Fw_Update(client);
403
404 return err;
405 }
406
407
elan_ts_hid_calibrate(struct i2c_client * client)408 static int elan_ts_hid_calibrate(struct i2c_client *client)
409 {
410 uint8_t flash_key[HID_CMD_LEN] = {0x04,0x00,0x23,0x00,0x03,0x00,0x04,CMD_W_PKT,0xc0,0xe1,0x5a};
411 uint8_t cal_cmd[HID_CMD_LEN] = {0x04,0x00,0x23,0x00,0x03,0x00,0x04,CMD_W_PKT,0x29,0x00,0x01};
412 int err = 0;
413 uint8_t resp[67] = {0x00};
414 uint8_t rek_resp[4] = {0x66,0x66,0x66,0x66};
415 struct elan_ts_data *ts = i2c_get_clientdata(client);
416
417 dev_info(&client->dev, "[elan] %s: Flash Key cmd\n", __func__);
418
419 err = ts->ops->send(flash_key, sizeof(flash_key));
420 if (err != sizeof(flash_key)) {
421 dev_err(&client->dev,
422 "[elan] %s: i2c_master_send failed\n",__func__);
423 return err;
424 }
425
426 err = ts->ops->send(cal_cmd, sizeof(cal_cmd));
427 if ( err != sizeof(cal_cmd)) {
428 dev_err(&client->dev, "[elan] %s: i2c_master_send failed\n",__func__);
429 return err;
430 }
431
432 err = ts->ops->poll();
433 if (err) {
434 dev_err(&client->dev,
435 "[elan] %s: wait for int low failed %d\n", __func__, err);
436 return err;
437 } else {
438 err = ts->ops->recv(resp,sizeof(resp));
439 if ( err == sizeof(resp)) {
440 if (memcmp(rek_resp, resp + 4, sizeof(rek_resp))) {
441 dev_err(&client->dev, "%s:%d calibrate failed\n", __func__,__LINE__);
442 return -EINVAL;
443 } else {
444 dev_info(&client->dev,"calibrate success\n");
445 return 0;
446 }
447
448 } else {
449 dev_err(&client->dev, "%s:%d recv calibrate data failed\n",__func__,__LINE__);
450 return -EINVAL;
451 }
452 }
453 }
454
elan_ts_normal_calibrate(struct i2c_client * client)455 static int elan_ts_normal_calibrate(struct i2c_client *client)
456 {
457 struct elan_ts_data *ts = i2c_get_clientdata(client);
458 uint8_t flash_key[] = {CMD_W_PKT, 0xc0, 0xe1, 0x5a};
459 uint8_t cal_cmd[] = {CMD_W_PKT, 0x29, 0x00, 0x01};
460 uint8_t rek_resp[4] = {0x66,0x66,0x66,0x66};
461 uint8_t resp[4] = {0x00};
462 int err = 0;
463
464 dev_info(&client->dev, "[elan] %s: Flash Key cmd\n", __func__);
465
466 err = ts->ops->send(flash_key, sizeof(flash_key));
467 if (err != sizeof(flash_key)) {
468 dev_err(&client->dev,
469 "[elan] %s: i2c_master_send failed\n",__func__);
470 return err;
471 }
472
473 err = ts->ops->send(cal_cmd, sizeof(cal_cmd));
474 if ( err != sizeof(cal_cmd) ) {
475 dev_err(&client->dev,
476 "[elan] %s: i2c_master_send failed\n",__func__);
477 return err;
478 }
479
480 err = ts->ops->poll();
481 if ( err ) {
482 } else {
483 err = ts->ops->recv(resp,sizeof(resp));
484 if ( err == sizeof(resp) ) {
485 if (memcmp(rek_resp, resp, sizeof(rek_resp))) {
486 dev_err(&client->dev, "%s:%d calibrate failed", __func__,__LINE__);
487 return -EINVAL;
488 } else {
489 dev_info(&client->dev,"calibrate success");
490 return 0;
491 }
492 } else {
493 dev_err(&client->dev, "%s:%d recv calibrate data failed",__func__,__LINE__);
494 return -EINVAL;
495 }
496 }
497 return 0;
498 }
499
elan_ts_calibrate(struct i2c_client * client)500 int elan_ts_calibrate(struct i2c_client *client)
501 {
502 struct elan_ts_data *ts = i2c_get_clientdata(client);
503 int err = 0;
504
505 if (ts->chip_type == HID_TYPE_PROTOCOL)
506 err = elan_ts_hid_calibrate(client);
507 else if(ts->chip_type == NORMAL_TYPE_PROTOCOL)
508 err = elan_ts_normal_calibrate(client);
509 return err;
510 }
511
check_cal_status(struct i2c_client * client)512 static int check_cal_status(struct i2c_client *client)
513 {
514 struct elan_ts_data *ts = i2c_get_clientdata(client);
515 const uint8_t check_rek_cmd[HID_CMD_LEN] = {0x04, 0x00, 0x23, 0x00, 0x03, 0x00, 0x04, 0x53, 0xD0, 0x00, 0x01};
516 const uint8_t rek_count[2] = {0xFF,0xFF};
517 uint8_t resp[67] = {0};
518 int err = 0;
519
520 err = ts->ops->send(check_rek_cmd, sizeof(check_rek_cmd));
521 if (err != sizeof(check_rek_cmd)) {
522 dev_err(&client->dev, "[elan] %s send check rek command failed\n", __func__);
523 return err;
524 }
525
526 err = ts->ops->poll();
527 if (err) {
528 dev_err(&client->dev, "[elan] %s wait int failed\n", __func__);
529 return err;
530 }
531
532 err = ts->ops->recv(resp, sizeof(resp));
533 if (err != sizeof(resp)){
534 dev_err(&client->dev, "[elan] %s recv check rek failed\n", __func__);
535 return err;
536 } else {
537 dev_info(&client->dev, "[elan] %s check rek resp 0x%2x:0x%2x:0x%2x:0x%2x\n",__func__,\
538 resp[6],resp[7],resp[8],resp[9]);
539
540 if (memcmp(resp+6, rek_count,2)) {
541 dev_info(&client->dev, "[elan] %s check ok!!\n",__func__);
542 return 0;
543 }
544 else {
545 dev_info(&client->dev, "[elan] %s check failed!!\n",__func__);
546 return -1;
547 }
548 }
549
550 }
551
elan_ts_check_calibrate(struct i2c_client * client)552 int elan_ts_check_calibrate(struct i2c_client *client)
553 {
554 int err = 0;
555 struct elan_ts_data *ts = i2c_get_clientdata(client);
556
557 if (ts->chip_type == HID_TYPE_PROTOCOL)
558 err = check_cal_status(client);
559 else
560 dev_info(&client->dev, "[elan] ok");
561
562 return err;
563 }
564
565
elan_read_fw_from_sdcard(struct elan_ts_data * ts)566 static int elan_read_fw_from_sdcard(struct elan_ts_data *ts)
567 {
568 dev_err(&ts->client->dev, "[elan] can not pass Google GKI, return\n");
569 return -1;
570 /*
571 * struct elan_update_fw_info *update = &ts->update_info;
572 * mm_segment_t oldfs;
573 * struct file *firmware_fp;
574 * int ret = 0;
575 * int retry = 0;
576 * int file_len;
577 * static uint8_t *fw_data_user;
578 *
579 * if ( fw_data_user != NULL)
580 * kfree(fw_data_user);
581 *
582 * oldfs = get_fs();
583 * set_fs(KERNEL_DS);
584 *
585 * for (retry = 0; retry < 5; retry++) {
586 * firmware_fp = filp_open(update->fw_local_path, O_RDONLY, 0);
587 * if ( IS_ERR(firmware_fp) ) {
588 * dev_err(&ts->client->dev, "[elan] retry to open user ekt file\n");
589 * mdelay(100);
590 * } else
591 * break;
592 * }
593 *
594 * if ( retry >= 5 ) {
595 * dev_err(&ts->client->dev,
596 * "[elan] open %s file error!!\n",update->fw_local_path);
597 * ret = -1;
598 * goto out_read_fw_from_user2;
599 * } else
600 * dev_dbg(&ts->client->dev,
601 * "[elan] open %s file sucess!!\n",update->fw_local_path);
602 *
603 * file_len = firmware_fp->f_path.dentry->d_inode->i_size;
604 * if (file_len == 0) {
605 * dev_dbg(&ts->client->dev,
606 * "[elan] Get File len err!!!!");
607 * ret = -2;
608 * goto out_read_fw_from_user1;
609 * }
610 *
611 * fw_data_user = kzalloc(file_len, GFP_KERNEL);
612 * if (fw_data_user == NULL) {
613 * dev_err(&ts->client->dev,
614 * "[elan] malloc fw_data err\n");
615 * ret = -3;
616 * goto out_read_fw_from_user1;
617 * }
618 *
619 * ret = firmware_fp->f_op->read(firmware_fp, fw_data_user,
620 * file_len, &firmware_fp->f_pos);
621 * if ( ret != file_len ) {
622 * dev_err(&ts->client->dev,
623 * "[elan] read EKT file size err, ret=%d!\n",ret);
624 * ret = -4;
625 * goto out_read_fw_from_user0;
626 * } else {
627 * update->FwData = fw_data_user;
628 * update->FwSize = file_len;
629 * update->PageNum = update->FwSize/132;
630 * ret = 0;
631 * }
632 *out_read_fw_from_user0:
633 *out_read_fw_from_user1:
634 * filp_close(firmware_fp, NULL);
635 *out_read_fw_from_user2:
636 * set_fs(oldfs);
637 *
638 * return ret;
639 */
640 }
641
get_driver_fw(struct elan_ts_data * ts)642 static int get_driver_fw(struct elan_ts_data *ts)
643 {
644 int i,vendor_num = 0, lcm_id;
645 struct elan_update_fw_info *update_info = &ts->update_info;
646 vendor_num = sizeof(g_vendor_map)/sizeof(g_vendor_map[0]);
647
648 /*if there are more than one display product, ODM should provid lcmid*/
649 lcm_id = 0x2ae2;
650
651 /*if there are more than one tp panle, ELAN should provide fwid*/
652
653 for (i = 0; i < vendor_num; i++) {
654 dev_err(&ts->client->dev,
655 "[elan] vendor name = %s, lcm_id = 0x%04x, vendor_id = 0x%04x\n",\
656 g_vendor_map[i].vendor_name,lcm_id, g_vendor_map[i].vendor_id);
657 if (lcm_id == g_vendor_map[i].vendor_id) {
658 update_info->FwData = g_vendor_map[i].fw_array;
659 update_info->FwSize = g_vendor_map[i].fw_size;
660 update_info->PageNum = g_vendor_map[i].fw_size/132;
661 dev_err(&ts->client->dev, "fwSize = %d, pagenum = %d\n", update_info->FwSize,update_info->PageNum );
662 return 0;
663 }
664 }
665
666 dev_err(&ts->client->dev,"[elan] ID is error, not support!!\n");
667 return -1;
668 }
669
670
elan_get_vendor_fw(struct elan_ts_data * ts,int type)671 int elan_get_vendor_fw(struct elan_ts_data *ts, int type)
672 {
673 int err = 0;
674 struct elan_update_fw_info *update_info = &ts->update_info;
675 const struct firmware *p_fw_entry;
676
677 if ( type == FROM_SYS_ETC_FIRMWARE) {
678 update_info->FwName = kasprintf(GFP_KERNEL, "elants_i2c.ekt");
679 if (!update_info->FwName)
680 return -ENOMEM;
681
682 err = request_firmware(&p_fw_entry, update_info->FwName, &ts->client->dev);
683 if ( err ) {
684 dev_err(&ts->client->dev,
685 "request_firmware fail err=%d\n",err);
686 return -1;
687 } else {
688 dev_dbg(&ts->client->dev, "Firmware Size=%zu",p_fw_entry->size);
689 update_info->FwData = p_fw_entry->data;
690 update_info->FwSize = p_fw_entry->size;
691 update_info->PageNum = update_info->FwSize/132;
692 dev_info(&ts->client->dev, "[elan] %d: FwSize %d, PageNum %d\n", __LINE__,
693 update_info->FwSize, update_info->PageNum );
694 }
695 } else if ( type == FROM_SDCARD_FIRMWARE ) {
696 update_info->FwName = kasprintf(GFP_KERNEL, "elants_i2c.ekt");
697 sprintf(update_info->fw_local_path, "%s%s", "/data/local/tmp", update_info->FwName);
698 dev_info(&ts->client->dev, "[elan] Update Firmware from %s\n", update_info->fw_local_path);
699
700 err = elan_read_fw_from_sdcard(ts);
701 if ( err ) {
702 dev_err(&ts->client->dev, "Get FW Data From %s failed\n",update_info->fw_local_path);
703 return -1;
704 }
705 } else if ( type == FROM_DRIVER_FIRMWARE ) {
706 err = get_driver_fw(ts);
707 if ( err ) {
708 dev_err(&ts->client->dev, "Get FW Data From driver failed\n");
709 return -1;
710 }
711 }
712 update_info->remark_id = get_unaligned_le16(&update_info->FwData[update_info->FwSize - 4]);
713 return err;
714 }
715
716
elan_check_update_flage(struct elan_ts_data * ts)717 void elan_check_update_flage(struct elan_ts_data *ts)
718 {
719 int New_FW_VERSION = 0;
720 int New_FW_ID = 0;
721 int err = 0;
722 int retry = 0;
723 struct elan_update_fw_info *update_info = &ts->update_info;
724 struct elan_fw_info *fw_info = &ts->fw_info;
725 int try = 30;
726
727 /*
728 ** support three methods to get fwdata.
729 * FROM_SYS_ETC_FIRMWARE :/system/firmware/elants_i2c.ekt
730 * FROM_SDCARD_FIRMWARE: /data/local/tmp/elants_i2c.ekt
731 * FROM_DRIVER_FIRMWARE: in driver code directory *.i
732 */
733 RETRY:
734
735 err = elan_get_vendor_fw(ts,ts->fw_store_type);
736 if (err) {
737 if (try--) {
738 msleep(100);
739 goto RETRY;
740 }
741 dev_err(&ts->client->dev, "[elan] ***counld not get fw,exit update flow!!***\n");
742 goto exit_fw_upgrade;
743 } else {
744 dev_err(&ts->client->dev,
745 "[elan]%d ***get fw success,enter update flow!! try count %d***\n",
746 __LINE__, 30-try);
747 }
748
749 if ( ts->recover == FORCED_UPGRADE ) {
750 dev_err(&ts->client->dev, "[elan] *** fw is miss, force update fw!! ***\n");
751 goto fw_upgrade;
752 }
753
754 /*
755 ** id and version index maybe change.
756 */
757 New_FW_ID = update_info->FwData[0xD5ED] << 8 | update_info->FwData[0XD5EC];
758 New_FW_VERSION = update_info->FwData[0x9F] << 8 | update_info->FwData[0x9E];
759
760 dev_info(&ts->client->dev, "[elan] FW_ID=0x%4x,New_FW_ID=0x%4x\n",fw_info->fw_id,New_FW_ID);
761 dev_info(&ts->client->dev, "[elan] FW_VERSION=0x%4x,New_FW_VERSION=0x%4x\n",fw_info->fw_ver,New_FW_VERSION);
762
763 if ((fw_info->fw_id&0xff) != (New_FW_ID&0xff)) {
764 dev_err(&ts->client->dev,"[elan] fw id is different, can not update!");
765 goto exit_fw_upgrade;
766 }
767
768 if ((fw_info->fw_ver&0xff) >= (New_FW_VERSION&0xff)) {
769 dev_info(&ts->client->dev,"[elan] fw version is newest!!\n");
770 goto exit_fw_upgrade;
771 }
772
773 fw_upgrade:
774 /*start update fw*/
775 elan_FW_Update(ts->client);
776
777 elan_ts_hw_reset(&ts->hw_info);
778 mdelay(300);
779
780 /*get fw msg*/
781 for (; retry < 3; retry++) {
782 err = elan__fw_packet_handler(ts->client);
783 if (err)
784 dev_err(&ts->client->dev, "[elan] After update fw get fw msg failed, retry=%d\n",retry);
785 else
786 break;
787 }
788 mdelay(200);
789 /*calibration*/
790 for (retry = 0; retry < 3; retry++) {
791 err = elan_ts_calibrate(ts->client);
792 if (err)
793 dev_err(&ts->client->dev, "[elan] After update fw calibrate failed, retry=%d\n",retry);
794 else {
795 err = elan_ts_check_calibrate(ts->client); /*ic reponse rek count,count != 0xff? "ok":"failed" */
796 if (err)
797 dev_err(&ts->client->dev, "[elan] After update fw check rek failed, retry=%d\n",retry);
798 else
799 break;
800 }
801 }
802
803 exit_fw_upgrade:
804
805 return;
806 }
807
808