PageRenderTime 940ms CodeModel.GetById 46ms RepoModel.GetById 1ms app.codeStats 1ms

/arch/arm/mach-msm/lge/lg_fw_diag_mtc.c

https://bitbucket.org/sammyz/iscream_thunderc-2.6.35-rebase
C | 837 lines | 566 code | 137 blank | 134 comment | 89 complexity | dc0f4de652c5edb0a5752d5fd18735ed MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
  1. /* arch/arm/mach-msm/lge/lg_fw_diag_mtc.c
  2. *
  3. * Copyright (C) 2009,2010 LGE, Inc.
  4. *
  5. * This software is licensed under the terms of the GNU General Public
  6. * License version 2, as published by the Free Software Foundation, and
  7. * may be copied, distributed, and modified under those terms.
  8. *
  9. * This program is distributed in the hope that it will be useful,
  10. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. * GNU General Public License for more details.
  13. *
  14. */
  15. #include <linux/module.h>
  16. #include <mach/lg_diagcmd.h>
  17. #include <mach/lg_fw_diag_mtc.h>
  18. #include <mach/lge_base64.h>
  19. #include <linux/unistd.h> /*for open/close */
  20. #include <linux/fcntl.h> /*for O_RDWR */
  21. #include <linux/fb.h> /* to handle framebuffer ioctls */
  22. #include <linux/ioctl.h>
  23. #include <linux/uaccess.h>
  24. #include <linux/syscalls.h> //for sys operations
  25. #include <linux/input.h> // for input_event
  26. #include <linux/fs.h> // for file struct
  27. #include <linux/types.h> // for ssize_t
  28. #include <linux/input.h> // for event parameters
  29. #include <linux/jiffies.h>
  30. #if 1 //LG_FW_MTC_GISELE
  31. #include <linux/crc-ccitt.h>
  32. #include <linux/delay.h>
  33. #define ESC_CHAR 0x7D
  34. #define CONTROL_CHAR 0x7E
  35. #define ESC_MASK 0x20
  36. #define CRC_16_L_SEED 0xFFFF
  37. #define CRC_16_L_STEP(xx_crc, xx_c) \
  38. crc_ccitt_byte(xx_crc, xx_c)
  39. void *lg_diag_mtc_req_pkt_ptr;
  40. unsigned short lg_diag_mtc_req_pkt_length;
  41. #endif //LG_FW_MTC_GISELE
  42. #ifndef LG_FW_DUAL_TOUCH
  43. #define LG_FW_DUAL_TOUCH
  44. #endif
  45. /*
  46. * EXTERNAL FUNCTION AND VARIABLE DEFINITIONS
  47. */
  48. extern PACK(void *) diagpkt_alloc(diagpkt_cmd_code_type code,
  49. unsigned int length);
  50. extern PACK(void *) diagpkt_free(PACK(void *)pkt);
  51. extern void send_to_arm9(void *pReq, void *pRsp);
  52. #if defined (CONFIG_MACH_MSM7X27_THUNDERC) || defined (LG_FW_ATS_ETA_MTC_KEY_LOGGING)
  53. extern unsigned int ats_mtc_log_mask;
  54. extern void diagpkt_commit(PACK(void *)pkt);
  55. #endif /*LG_FW_ATS_ETA_MTC_KEY_LOGGING */
  56. /*
  57. * LOCAL DEFINITIONS AND DECLARATIONS FOR MODULE
  58. *
  59. * This section contains local definitions for constants, macros, types,
  60. * variables and other items needed by this module.
  61. */
  62. #if defined (CONFIG_MACH_MSM7X27_THUNDERC) || defined (LG_FW_ATS_ETA_MTC_KEY_LOGGING)
  63. #define JIFFIES_TO_MS(t) ((t) * 1000 / HZ)
  64. #endif /*LG_FW_ATS_ETA_MTC_KEY_LOGGING */
  65. extern mtc_user_table_entry_type mtc_mstr_tbl[MTC_MSTR_TBL_SIZE];
  66. unsigned char g_diag_mtc_check = 0;
  67. static char mtc_running = 0;
  68. unsigned char g_diag_mtc_capture_rsp_num = 0;
  69. static mtc_lcd_info_type lcd_info;
  70. extern int diagchar_ioctl(unsigned int iocmd, unsigned long ioarg);
  71. static int ats_mtc_set_lcd_info(mtc_scrn_id_type ScreenType);
  72. static ssize_t read_framebuffer(byte * pBuf);
  73. typedef enum {
  74. /*
  75. * 0 Move pointer to the specified location
  76. * 1 Move the pointer by the specified values
  77. * 2 Tap at the current location
  78. * 3 Double tap at the current location
  79. * 4 Touch down at the current location
  80. * 5 Touch up at the current location
  81. * */
  82. MOVE_ABSOLUTE,
  83. MOVE_RELATIVE,
  84. TAP,
  85. DOUBLE_TAP,
  86. TOUCH_DOWN,
  87. TOUCH_UP
  88. } TOUCH_ACTIONS;
  89. #if 1 //LG_FW_MTC_GISELE
  90. /*
  91. * FUNCTION add_hdlc_packet.
  92. */
  93. static void add_hdlc_packet(struct mtc_data_buffer *mb, char data)
  94. {
  95. mb->data[mb->data_length++] = data;
  96. //if (mb->data_length == BUFFER_MAX_SIZE) {
  97. if (mb->data_length >= BUFFER_MAX_SIZE) {
  98. mb->data_length = BUFFER_MAX_SIZE;
  99. msleep(10);
  100. if (diagchar_ioctl (DIAG_IOCTL_BULK_DATA, (unsigned long)mb)) {
  101. printk(KERN_ERR "[MTC] %s: diagchar_ioctl error\n", __func__);
  102. }
  103. mb->data_length = 0;
  104. }
  105. }
  106. /*
  107. * FUNCTION add_hdlc_esc_packet.
  108. */
  109. static void add_hdlc_esc_packet(struct mtc_data_buffer *mb, char data)
  110. {
  111. if (data == ESC_CHAR || data == CONTROL_CHAR) {
  112. add_hdlc_packet(mb, ESC_CHAR);
  113. add_hdlc_packet(mb, (data ^ ESC_MASK));
  114. }
  115. else {
  116. add_hdlc_packet(mb, data);
  117. }
  118. }
  119. /*
  120. * FUNCTION mtc_send_hdlc_packet.
  121. */
  122. static void mtc_send_hdlc_packet(byte * pBuf, int len)
  123. {
  124. int i;
  125. struct mtc_data_buffer *mb;
  126. word crc = CRC_16_L_SEED;
  127. mb = kzalloc(sizeof(struct mtc_data_buffer), GFP_ATOMIC);
  128. if (mb == NULL) {
  129. printk(KERN_ERR "[MTC] %s: failed to alloc memory\n", __func__);
  130. return;
  131. }
  132. //Generate crc data.
  133. for (i = 0; i < len; i++) {
  134. add_hdlc_esc_packet(mb, pBuf[i]);
  135. crc = CRC_16_L_STEP(crc, (word) pBuf[i]);
  136. }
  137. crc ^= CRC_16_L_SEED;
  138. add_hdlc_esc_packet(mb, ((unsigned char)crc));
  139. add_hdlc_esc_packet(mb, ((unsigned char)((crc >> 8) & 0xFF)));
  140. add_hdlc_packet(mb, CONTROL_CHAR);
  141. if (diagchar_ioctl(DIAG_IOCTL_BULK_DATA, (unsigned long)mb)) {
  142. printk(KERN_ERR "[MTC] %s: ioctl ignored\n", __func__);
  143. }
  144. kfree(mb);
  145. mb = NULL;
  146. }
  147. /*
  148. * FUNCTION translate_key_code.
  149. */
  150. dword translate_key_code(dword keycode)
  151. {
  152. if (keycode == KERNELFOCUSKEY)
  153. return KERNELCAMERAKEY;
  154. else
  155. return keycode;
  156. }
  157. /*
  158. * FUNCTION mtc_send_key_log_packet.
  159. */
  160. void mtc_send_key_log_packet(unsigned long keycode, unsigned long state)
  161. {
  162. ext_msg_type msg;
  163. dword sendKeyValue = 0;
  164. /* LGE_CHANGE [dojip.kim@lge.com] 2010-06-04 [LS670]
  165. * don't send a raw diag packet in running MTC
  166. */
  167. if (mtc_running)
  168. return;
  169. memset(&msg, 0, sizeof(ext_msg_type));
  170. sendKeyValue = translate_key_code(keycode);
  171. msg.cmd_code = 121;
  172. msg.ts_type = 0; //2;
  173. msg.num_args = 2;
  174. msg.drop_cnt = 0;
  175. //ts_get(&msg.time[0]);
  176. msg.time[0] = 0;
  177. msg.time[1] = 0;
  178. msg.line_number = 261;
  179. msg.ss_id = 0;
  180. msg.ss_mask = 2;
  181. msg.args[0] = sendKeyValue;
  182. msg.args[1] = state;
  183. memcpy(&msg.code[0], "Debounced %d", sizeof("Debounced %d"));
  184. //msg.code[12] = '\0';
  185. memcpy(&msg.file_name[0], "DiagDaemon.c", sizeof("DiagDaemon.c"));
  186. //msg.fle_name[13] = '\0';
  187. mtc_send_hdlc_packet((byte *) & msg, sizeof(ext_msg_type));
  188. }
  189. EXPORT_SYMBOL(mtc_send_key_log_packet);
  190. #endif //LG_FW_MTC_GISELE
  191. /*
  192. * INTERNAL FUNCTION DEFINITIONS
  193. */
  194. PACK(void *) LGF_MTCProcess(PACK(void *)req_pkt_ptr,/* pointer to request packet */
  195. unsigned short pkt_len)
  196. { /* length of request packet */
  197. DIAG_MTC_F_req_type *req_ptr = (DIAG_MTC_F_req_type *) req_pkt_ptr;
  198. DIAG_MTC_F_rsp_type *rsp_ptr = NULL;
  199. mtc_func_type func_ptr = NULL;
  200. int nIndex = 0;
  201. g_diag_mtc_check = 1;
  202. mtc_running = 1;
  203. for (nIndex = 0; nIndex < MTC_MSTR_TBL_SIZE; nIndex++) {
  204. if (mtc_mstr_tbl[nIndex].cmd_code == req_ptr->hdr.sub_cmd) {
  205. if (mtc_mstr_tbl[nIndex].which_procesor ==
  206. MTC_ARM11_PROCESSOR)
  207. func_ptr = mtc_mstr_tbl[nIndex].func_ptr;
  208. break;
  209. }
  210. else if (mtc_mstr_tbl[nIndex].cmd_code == MTC_MAX_CMD)
  211. break;
  212. else
  213. continue;
  214. }
  215. if (func_ptr != NULL) {
  216. printk(KERN_INFO "[MTC]cmd_code : [0x%X], sub_cmd : [0x%X]\n",
  217. req_ptr->hdr.cmd_code, req_ptr->hdr.sub_cmd);
  218. rsp_ptr = func_ptr((DIAG_MTC_F_req_type *) req_ptr);
  219. } else
  220. send_to_arm9((void *)req_ptr, (void *)rsp_ptr);
  221. /* LGE_CHANGE [dojip.kim@lge.com] 2010-06-04 [LS670] */
  222. mtc_running = 0;
  223. return (rsp_ptr);
  224. }
  225. EXPORT_SYMBOL(LGF_MTCProcess);
  226. DIAG_MTC_F_rsp_type *mtc_info_req_proc(DIAG_MTC_F_req_type * pReq)
  227. {
  228. unsigned int rsp_len;
  229. DIAG_MTC_F_rsp_type *pRsp;
  230. printk(KERN_INFO "[MTC]mtc_info_req_proc\n");
  231. rsp_len = sizeof(mtc_info_rsp_type);
  232. printk(KERN_INFO "[MTC] mtc_info_req_proc rsp_len :(%d)\n", rsp_len);
  233. pRsp = (DIAG_MTC_F_rsp_type *) diagpkt_alloc(DIAG_MTC_F, rsp_len);
  234. if (pRsp == NULL) {
  235. printk(KERN_ERR "[MTC] diagpkt_alloc failed\n");
  236. /* LGE_CHANGE [dojip.kim@lge.com] 2010-06-04, null check */
  237. return pRsp;
  238. }
  239. pRsp->hdr.cmd_code = DIAG_MTC_F;
  240. pRsp->hdr.sub_cmd = MTC_INFO_REQ_CMD;
  241. if (pReq->mtc_req.info.screen_id == MTC_SUB_LCD) // N/A
  242. {
  243. printk(KERN_ERR "[MTC]mtc_info_req_proc, "
  244. "sub lcd is not supported\n");
  245. return pRsp;
  246. }
  247. if (pReq->mtc_req.info.screen_id == MTC_MAIN_LCD) {
  248. ats_mtc_set_lcd_info(MTC_MAIN_LCD);
  249. pRsp->mtc_rsp.info.scrn_id = MTC_MAIN_LCD;
  250. }
  251. #ifdef LGE_USES_SUBLCD
  252. else if (pReq->mtc_req.info.screen_id == MTC_SUB_LCD) {
  253. ats_mtc_set_lcd_info(MTC_SUB_LCD);
  254. pRsp->mtc_rsp.info.scrn_id = MTC_SUB_LCD;
  255. }
  256. #endif
  257. else {
  258. printk(KERN_ERR "[MTC]mtc_info_req_proc, "
  259. "unknown screen_id type : %d\n",
  260. pRsp->mtc_rsp.info.scrn_id);
  261. return pRsp;
  262. }
  263. pRsp->mtc_rsp.info.scrn_width = lcd_info.width_max;
  264. pRsp->mtc_rsp.info.scrn_height = lcd_info.height_max;
  265. pRsp->mtc_rsp.info.bits_pixel = lcd_info.bits_pixel;
  266. return pRsp;
  267. }
  268. static int ats_mtc_set_lcd_info(mtc_scrn_id_type ScreenType)
  269. {
  270. struct fb_var_screeninfo fb_varinfo;
  271. int fbfd;
  272. if ((fbfd = sys_open("/dev/graphics/fb0", O_RDWR, 0)) == -1) {
  273. printk(KERN_ERR "[MTC]ats_mtc_set_lcd_info, Can't open %s\n",
  274. "/dev/graphics/fb0");
  275. return 0;
  276. }
  277. memset((void *)&fb_varinfo, 0, sizeof(struct fb_var_screeninfo));
  278. if (sys_ioctl(fbfd, FBIOGET_VSCREENINFO, (long unsigned int)&fb_varinfo)
  279. < 0) {
  280. printk(KERN_ERR "[MTC]ats_mtc_set_lcd_info, ioctl failed\n");
  281. return 0;
  282. }
  283. printk(KERN_INFO
  284. "[MTC]ats_mtc_set_lcd_info, fbvar.xres= %d, fbvar.yres= %d, fbvar.pixel= %d\n",
  285. fb_varinfo.xres, fb_varinfo.yres, fb_varinfo.bits_per_pixel);
  286. sys_close(fbfd);
  287. if (ScreenType == MTC_MAIN_LCD) {
  288. lcd_info.id = MTC_MAIN_LCD;
  289. lcd_info.width_max = fb_varinfo.xres;
  290. lcd_info.height_max = fb_varinfo.yres;
  291. }
  292. #if defined (LG_SUBLCD_INCLUDE)
  293. else if (ScreenType == MTC_SUB_LCD) {
  294. lcd_info.id = MTC_SUB_LCD;
  295. lcd_info.width_max = fb_varinfo.xres;
  296. lcd_info.height_max = fb_varinfo.yres;
  297. }
  298. #endif
  299. //To Get the Bits Depth
  300. lcd_info.bits_pixel = fb_varinfo.bits_per_pixel;
  301. if (lcd_info.bits_pixel == MTC_BIT_65K) {
  302. lcd_info.mask.blue = MTC_65K_CMASK_BLUE;
  303. lcd_info.mask.green = MTC_65K_CMASK_GREEN;
  304. lcd_info.mask.red = MTC_65K_CMASK_RED;
  305. } else if (lcd_info.bits_pixel == MTC_BIT_262K) {
  306. lcd_info.mask.blue = MTC_262K_CMASK_BLUE;
  307. lcd_info.mask.green = MTC_262K_CMASK_GREEN;
  308. lcd_info.mask.red = MTC_262K_CMASK_RED;
  309. } else // default 16 bit
  310. {
  311. lcd_info.bits_pixel = MTC_BIT_65K;
  312. lcd_info.mask.blue = MTC_65K_CMASK_BLUE;
  313. lcd_info.mask.green = MTC_65K_CMASK_GREEN;
  314. lcd_info.mask.red = MTC_65K_CMASK_RED;
  315. }
  316. lcd_info.degrees = 0; //No rotation .. manual Data
  317. return 1;
  318. }
  319. // from GISELE
  320. DIAG_MTC_F_rsp_type *mtc_capture_screen(DIAG_MTC_F_req_type * pReq)
  321. {
  322. unsigned int rsp_len;
  323. static DIAG_MTC_F_rsp_type *pCaputureRsp;
  324. ssize_t bmp_size;
  325. printk(KERN_INFO "[MTC]mtc_capture_screen\n");
  326. /* LGE_CHANGE [dojip.kim@lge.com] 2010-06-04,
  327. * allocation the memory for bmp_data
  328. */
  329. rsp_len = sizeof(mtc_capture_rsp_type) + MTC_SCRN_BUF_SIZE_MAX;
  330. printk(KERN_INFO "[MTC] mtc_capture_screen rsp_len :(%d)\n", rsp_len);
  331. if (pCaputureRsp == NULL) {
  332. printk(KERN_ERR "[MTC] MEMORY ALLOC\n");
  333. pCaputureRsp =
  334. (DIAG_MTC_F_rsp_type *) diagpkt_alloc(DIAG_MTC_F, rsp_len);
  335. if (pCaputureRsp == NULL) {
  336. printk(KERN_ERR "[MTC] diagpkt_alloc failed\n");
  337. /* LGE_CHANGE [dojip.kim@lge.com] 2010-06-04, null check */
  338. return pCaputureRsp;
  339. }
  340. }
  341. pCaputureRsp->hdr.cmd_code = DIAG_MTC_F;
  342. pCaputureRsp->hdr.sub_cmd = MTC_CAPTURE_REQ_CMD;
  343. pCaputureRsp->mtc_rsp.capture.scrn_id = lcd_info.id;
  344. pCaputureRsp->mtc_rsp.capture.bmp_width = lcd_info.width_max;
  345. pCaputureRsp->mtc_rsp.capture.bmp_height = lcd_info.height_max;
  346. pCaputureRsp->mtc_rsp.capture.bits_pixel = lcd_info.bits_pixel;
  347. pCaputureRsp->mtc_rsp.capture.mask.blue = lcd_info.mask.blue;
  348. pCaputureRsp->mtc_rsp.capture.mask.green = lcd_info.mask.green;
  349. pCaputureRsp->mtc_rsp.capture.mask.red = lcd_info.mask.red;
  350. memset(pCaputureRsp->mtc_rsp.capture.bmp_data, 0,
  351. MTC_SCRN_BUF_SIZE_MAX);
  352. bmp_size = read_framebuffer(pCaputureRsp->mtc_rsp.capture.bmp_data);
  353. printk(KERN_INFO "[MTC]mtc_capture_screen, "
  354. "Read framebuffer & Bmp convert complete.. %d\n",
  355. (int)bmp_size);
  356. mtc_send_hdlc_packet((byte *) & pCaputureRsp->mtc_rsp.capture,
  357. (int)rsp_len);
  358. return NULL; // no response packet
  359. }
  360. static ssize_t read_framebuffer(byte * pBuf)
  361. {
  362. struct file *phMscd_Filp = NULL;
  363. ssize_t read_size = 0;
  364. mm_segment_t old_fs = get_fs();
  365. set_fs(get_ds());
  366. phMscd_Filp = filp_open("/dev/graphics/fb0", O_RDONLY | O_LARGEFILE, 0);
  367. if (!phMscd_Filp)
  368. printk("open fail screen capture \n");
  369. read_size = phMscd_Filp->f_op->read(phMscd_Filp,
  370. pBuf, MTC_SCRN_BUF_SIZE_MAX, &phMscd_Filp->f_pos);
  371. filp_close(phMscd_Filp, NULL);
  372. set_fs(old_fs);
  373. return read_size;
  374. }
  375. #if defined (CONFIG_MACH_MSM7X27_THUNDERC) || defined (LG_FW_ATS_ETA_MTC_KEY_LOGGING)
  376. static char eta_prev_action = 0xff;
  377. struct ats_mtc_key_log_type ats_mtc_key_log;
  378. extern unsigned int ats_mtc_log_mask;
  379. void ats_eta_mtc_key_logging(int scancode, unsigned char keystate)
  380. {
  381. /* LGE_CHANGE [dojip.kim@lge.com] 2010-06-04 [LS670]
  382. * don't send a raw diag packet in running MTC
  383. */
  384. if (mtc_running)
  385. return;
  386. /*
  387. 23 bytes for key log -> will be encoded to 32 byte (base64)
  388. CMD_CODE 1 (0xF0)
  389. SUB_CMD 1 (0x08)
  390. LOG_ID 1 (1 key, 2 touch)
  391. LOG_LEN 2 (data length in bytes)
  392. LOG_DATA LOG_LEN = 18
  393. - TIME 8 (timestamp in milliseconds)
  394. - HOLD 1 (Press or release)
  395. - KEYCODE 1
  396. - ACTIVE_UIID 8 (Activated UI ID)
  397. */
  398. if((ats_mtc_log_mask&0x00000001) != 0) { /* ETA_LOGITEM_KEY */
  399. ats_mtc_key_log.log_id = 1; //LOG_ID, 1 key, 2 touch
  400. ats_mtc_key_log.log_len = 18; //LOG_LEN
  401. switch(scancode) {
  402. /* camera focus */
  403. case 247:
  404. scancode = 32;
  405. break;
  406. /* camera capture */
  407. case 212:
  408. scancode = 65;
  409. break;
  410. }
  411. ats_mtc_key_log.x_hold = (unsigned int)keystate; // hold
  412. ats_mtc_key_log.y_code = (unsigned int)scancode; // key code
  413. printk(KERN_INFO "[ETA] key code 0x%X, hold : %d \n",scancode, keystate);
  414. /*
  415. if(g_diag_mtc_check == 0)
  416. ats_mtc_send_key_log_to_eta(&ats_mtc_key_log);
  417. else
  418. */
  419. mtc_send_key_log_data(&ats_mtc_key_log);
  420. }
  421. }
  422. EXPORT_SYMBOL(ats_eta_mtc_key_logging);
  423. /*
  424. 27 bytes for key log -> will be encoded to ?? byte (base64)
  425. CMD_CODE 1 (0xF0)
  426. SUB_CMD 1 (0x08)
  427. LOG_ID 1 (1 key, 2 touch)
  428. LOG_LEN 2 (data length in bytes)
  429. LOG_DATA LOG_LEN = 22
  430. - TIME 8 (timestamp in milliseconds)
  431. - SCREEN_ID 1
  432. - ACTION 1 (Touch-action Type)
  433. - X 2 (Absolute X Coordinate)
  434. - Y 2 (Absolute Y Coordinate)
  435. - ACTIVE_UIID 8 (Activated UI ID)
  436. */
  437. void ats_eta_mtc_touch_logging (int pendown, int x, int y)
  438. {
  439. /* LGE_CHANGE [dojip.kim@lge.com] 2010-06-04 [LS670]
  440. * don't send a raw diag packet in running MTC
  441. */
  442. if (mtc_running)
  443. return;
  444. if((ats_mtc_log_mask&0x00000002) != 0) {
  445. ats_mtc_key_log.log_id = 2; //LOG_ID, 1 key, 2 touch
  446. ats_mtc_key_log.log_len = 22; //LOG_LEN
  447. if (!pendown) { // release
  448. ats_mtc_key_log.action = (unsigned char)TOUCH_UP;
  449. eta_prev_action = TOUCH_UP;
  450. }
  451. else { // down
  452. if(eta_prev_action == TOUCH_DOWN) {
  453. ats_mtc_key_log.action = (unsigned char)MOVE_ABSOLUTE;
  454. // do not need to response all move to events
  455. if(g_diag_mtc_check == 1)
  456. mdelay(50);
  457. }
  458. else
  459. ats_mtc_key_log.action = (unsigned char)TOUCH_DOWN;
  460. eta_prev_action = TOUCH_DOWN;
  461. }
  462. ats_mtc_key_log.x_hold = x;
  463. ats_mtc_key_log.y_code = y;
  464. printk(KERN_INFO "[ETA] TOUCH X : %d, Y : %d \n",
  465. ats_mtc_key_log.x_hold, ats_mtc_key_log.y_code);
  466. /*
  467. if(g_diag_mtc_check == 0)
  468. ats_mtc_send_key_log_to_eta(&ats_mtc_key_log);
  469. else
  470. */
  471. mtc_send_key_log_data(&ats_mtc_key_log);
  472. }
  473. }
  474. EXPORT_SYMBOL(ats_eta_mtc_touch_logging);
  475. DIAG_MTC_F_rsp_type *mtc_logging_mask_req_proc(DIAG_MTC_F_req_type * pReq)
  476. {
  477. unsigned int rsp_len;
  478. DIAG_MTC_F_rsp_type *pRsp;
  479. rsp_len = sizeof(mtc_log_req_type);
  480. printk(KERN_INFO "[MTC] mtc_logging_mask_req_proc rsp_len :(%d)\n",
  481. rsp_len);
  482. pRsp = (DIAG_MTC_F_rsp_type *) diagpkt_alloc(DIAG_MTC_F, rsp_len);
  483. if (pRsp == NULL) {
  484. printk(KERN_ERR "[MTC] diagpkt_alloc failed\n");
  485. return pRsp;
  486. }
  487. switch (pReq->mtc_req.log.mask) {
  488. case 0x00000000: //ETA_LOGMASK_DISABLE_ALL:
  489. case 0xFFFFFFFF: //ETA_LOGMASK_ENABLE_ALL:
  490. case 0x00000001: //ETA_LOGITEM_KEY:
  491. case 0x00000002: //ETA_LOGITEM_TOUCHPAD:
  492. case 0x00000003: //ETA_LOGITME_KEYTOUCH:
  493. ats_mtc_log_mask = pReq->mtc_req.log.mask;
  494. pRsp->mtc_rsp.log.mask = ats_mtc_log_mask;
  495. break;
  496. default:
  497. ats_mtc_log_mask = 0x00000000; // //ETA_LOGMASK_DISABLE_ALL
  498. pRsp->mtc_rsp.log.mask = ats_mtc_log_mask;
  499. break;
  500. }
  501. return pRsp;
  502. }
  503. void mtc_send_key_log_data(struct ats_mtc_key_log_type *p_ats_mtc_key_log)
  504. {
  505. unsigned int rsp_len;
  506. DIAG_MTC_F_rsp_type *pRsp;
  507. rsp_len = sizeof(mtc_log_data_rsp_type);
  508. printk(KERN_INFO "[MTC] mtc_send_key_log_data rsp_len :(%d)\n",
  509. rsp_len);
  510. pRsp = (DIAG_MTC_F_rsp_type *) diagpkt_alloc(DIAG_MTC_F, rsp_len);
  511. if (pRsp == NULL) {
  512. printk(KERN_ERR "[MTC] diagpkt_alloc failed\n");
  513. /* LGE_CHANGE [dojip.kim@lge.com] 2010-06-04, null check */
  514. //diagpkt_commit(pRsp);
  515. return;
  516. }
  517. pRsp->hdr.cmd_code = DIAG_MTC_F;
  518. pRsp->hdr.sub_cmd = MTC_LOG_REQ_CMD;
  519. //LOG_ID, 1 key, 2 touch
  520. pRsp->mtc_rsp.log_data.log_id = p_ats_mtc_key_log->log_id;
  521. //LOG_LEN
  522. pRsp->mtc_rsp.log_data.log_len = p_ats_mtc_key_log->log_len;
  523. // key
  524. if (p_ats_mtc_key_log->log_id == 1) {
  525. pRsp->mtc_rsp.log_data.log_type.log_data_key.time =
  526. (unsigned long long)JIFFIES_TO_MS(jiffies);
  527. // hold
  528. pRsp->mtc_rsp.log_data.log_type.log_data_key.hold =
  529. (unsigned char)((p_ats_mtc_key_log->x_hold) & 0xFF);
  530. //key code
  531. pRsp->mtc_rsp.log_data.log_type.log_data_key.keycode =
  532. ((p_ats_mtc_key_log->y_code) & 0xFF);
  533. pRsp->mtc_rsp.log_data.log_type.log_data_key.active_uiid = 0;
  534. }
  535. // touch
  536. else {
  537. pRsp->mtc_rsp.log_data.log_type.log_data_touch.time =
  538. (unsigned long long)JIFFIES_TO_MS(jiffies);
  539. // MAIN LCD
  540. pRsp->mtc_rsp.log_data.log_type.log_data_touch.screen_id =
  541. (unsigned char)1;
  542. pRsp->mtc_rsp.log_data.log_type.log_data_touch.action =
  543. (unsigned char)p_ats_mtc_key_log->action;
  544. pRsp->mtc_rsp.log_data.log_type.log_data_touch.x =
  545. (unsigned short)p_ats_mtc_key_log->x_hold;
  546. pRsp->mtc_rsp.log_data.log_type.log_data_touch.y =
  547. (unsigned short)p_ats_mtc_key_log->y_code;
  548. pRsp->mtc_rsp.log_data.log_type.log_data_touch.active_uiid = 0;
  549. }
  550. diagpkt_commit(pRsp);
  551. }
  552. EXPORT_SYMBOL(mtc_send_key_log_data);
  553. #endif /*LG_FW_ATS_ETA_MTC_KEY_LOGGING */
  554. DIAG_MTC_F_rsp_type *mtc_null_rsp(DIAG_MTC_F_req_type * pReq)
  555. {
  556. unsigned int rsp_len;
  557. DIAG_MTC_F_rsp_type *pRsp;
  558. rsp_len = sizeof(mtc_req_hdr_type);
  559. printk(KERN_INFO "[MTC] mtc_null_rsp rsp_len :(%d)\n", rsp_len);
  560. pRsp = (DIAG_MTC_F_rsp_type *) diagpkt_alloc(DIAG_MTC_F, rsp_len);
  561. if (pRsp == NULL) {
  562. printk(KERN_ERR "[MTC] diagpkt_alloc failed\n");
  563. }
  564. pRsp->hdr.cmd_code = pReq->hdr.cmd_code;
  565. pRsp->hdr.sub_cmd = pReq->hdr.sub_cmd;
  566. return pRsp;
  567. }
  568. DIAG_MTC_F_rsp_type *mtc_execute(DIAG_MTC_F_req_type * pReq)
  569. {
  570. int ret;
  571. char cmdstr[100];
  572. int fd;
  573. unsigned int req_len = 0;
  574. unsigned int rsp_len;
  575. DIAG_MTC_F_rsp_type *pRsp = NULL;
  576. unsigned char *mtc_cmd_buf_encoded = NULL;
  577. int lenb64 = 0;
  578. char *envp[] = {
  579. "HOME=/",
  580. "TERM=linux",
  581. NULL,
  582. };
  583. char *argv[] = {
  584. "/system/bin/mtc",
  585. cmdstr,
  586. NULL,
  587. };
  588. printk(KERN_INFO "[MTC]mtc_execute\n");
  589. switch (pReq->hdr.sub_cmd) {
  590. case MTC_KEY_EVENT_REQ_CMD:
  591. req_len = sizeof(mtc_key_req_type);
  592. rsp_len = sizeof(mtc_key_req_type);
  593. printk(KERN_INFO "[MTC] KEY_EVENT_REQ rsp_len :(%d)\n",
  594. rsp_len);
  595. pRsp =
  596. (DIAG_MTC_F_rsp_type *) diagpkt_alloc(DIAG_MTC_F, rsp_len);
  597. if (pRsp == NULL) {
  598. printk(KERN_ERR "[MTC] diagpkt_alloc failed\n");
  599. return pRsp;
  600. }
  601. pRsp->mtc_rsp.key.hold = pReq->mtc_req.key.hold;
  602. pRsp->mtc_rsp.key.key_code = pReq->mtc_req.key.key_code;
  603. break;
  604. case MTC_TOUCH_REQ_CMD:
  605. req_len = sizeof(mtc_touch_req_type);
  606. rsp_len = sizeof(mtc_touch_req_type);
  607. printk(KERN_INFO "[MTC] TOUCH_EVENT_REQ rsp_len :(%d)\n",
  608. rsp_len);
  609. pRsp =
  610. (DIAG_MTC_F_rsp_type *) diagpkt_alloc(DIAG_MTC_F, rsp_len);
  611. if (pRsp == NULL) {
  612. printk(KERN_ERR "[MTC] diagpkt_alloc failed\n");
  613. return pRsp;
  614. }
  615. pRsp->mtc_rsp.touch.screen_id = pReq->mtc_req.touch.screen_id;
  616. pRsp->mtc_rsp.touch.action = pReq->mtc_req.touch.action;
  617. pRsp->mtc_rsp.touch.x = pReq->mtc_req.touch.x;
  618. pRsp->mtc_rsp.touch.y = pReq->mtc_req.touch.y;
  619. break;
  620. default:
  621. printk(KERN_ERR "[MTC] unknown sub_cmd : (%d)\n",
  622. pReq->hdr.sub_cmd);
  623. break;
  624. }
  625. if (NULL == pRsp) {
  626. printk(KERN_ERR "[MTC] pRsp is Null\n");
  627. return pRsp;
  628. }
  629. pRsp->hdr.cmd_code = pReq->hdr.cmd_code;
  630. pRsp->hdr.sub_cmd = pReq->hdr.sub_cmd;
  631. mtc_cmd_buf_encoded = kmalloc(sizeof(unsigned char) * 50, GFP_KERNEL);
  632. memset(cmdstr, 0x00, 50);
  633. memset(mtc_cmd_buf_encoded, 0x00, 50);
  634. lenb64 =
  635. base64_encode((char *)pReq, req_len, (char *)mtc_cmd_buf_encoded);
  636. fd = sys_open((const char __user *)"/system/bin/mtc", O_RDONLY, 0);
  637. if (fd < 0) {
  638. printk ("\n [MTC]can not open /system/bin/mtc "
  639. "- execute /system/bin/mtc\n");
  640. sprintf(cmdstr, "/system/bin/mtc ");
  641. }
  642. else {
  643. memcpy((void *)cmdstr, (void *)mtc_cmd_buf_encoded, lenb64);
  644. /*
  645. printk ("[MTC] cmdstr[16] : %d, cmdstr[17] : %d, cmdstr[18] : %d",
  646. cmdstr[16], cmdstr[17], cmdstr[18]);
  647. printk ("[MTC] cmdstr[19] : %d, cmdstr[20] : %d, cmdstr[21] : %d",
  648. cmdstr[19], cmdstr[20], cmdstr[21]);
  649. */
  650. printk("\n [MTC]execute /system/bin/mtc, %s\n", cmdstr);
  651. sys_close(fd);
  652. }
  653. // END: eternalblue@lge.com.2009-10-23
  654. printk(KERN_INFO "[MTC]execute mtc : data - %s\n\n", cmdstr);
  655. ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);
  656. if (ret != 0) {
  657. printk(KERN_ERR "[MTC]execute failed, ret = %d\n", ret);
  658. }
  659. else {
  660. printk(KERN_INFO "[MTC]execute ok, ret = %d\n", ret);
  661. }
  662. kfree(mtc_cmd_buf_encoded);
  663. return pRsp;
  664. }
  665. EXPORT_SYMBOL(mtc_execute);
  666. /* USAGE (same as testmode
  667. * 1. If you want to handle at ARM9 side,
  668. * you have to insert fun_ptr as NULL and mark ARM9_PROCESSOR
  669. * 2. If you want to handle at ARM11 side ,
  670. * you have to insert fun_ptr as you want and mark AMR11_PROCESSOR.
  671. */
  672. mtc_user_table_entry_type mtc_mstr_tbl[MTC_MSTR_TBL_SIZE] = {
  673. /*sub_command fun_ptr which procesor*/
  674. {MTC_INFO_REQ_CMD, mtc_info_req_proc, MTC_ARM11_PROCESSOR},
  675. {MTC_CAPTURE_REQ_CMD, mtc_capture_screen, MTC_ARM11_PROCESSOR},
  676. {MTC_KEY_EVENT_REQ_CMD, mtc_execute, MTC_ARM11_PROCESSOR},
  677. {MTC_TOUCH_REQ_CMD, mtc_execute, MTC_ARM11_PROCESSOR},
  678. #if defined (CONFIG_MACH_MSM7X27_THUNDERC) || defined (LG_FW_ATS_ETA_MTC_KEY_LOGGING)
  679. {MTC_LOGGING_MASK_REQ_CMD, mtc_logging_mask_req_proc,MTC_ARM11_PROCESSOR},
  680. {MTC_LOG_REQ_CMD, NULL, MTC_ARM11_PROCESSOR}, /*mtc_send_key_log_data */
  681. #endif /*LG_FW_ATS_ETA_MTC_KEY_LOGGING */
  682. {MTC_PHONE_RESTART_REQ_CMD, NULL, MTC_ARM9_PROCESSOR},
  683. {MTC_FACTORY_RESET, mtc_null_rsp, MTC_ARM9_ARM11_BOTH},
  684. {MTC_PHONE_REPORT, NULL, MTC_ARM9_PROCESSOR},
  685. {MTC_PHONE_STATE, mtc_null_rsp, MTC_NOT_SUPPORTED},
  686. {MTC_CAPTURE_PROP, mtc_null_rsp, MTC_NOT_SUPPORTED},
  687. {MTC_NOTIFICATION_REQUEST, mtc_null_rsp, MTC_NOT_SUPPORTED},
  688. {MTC_CUR_PROC_NAME_REQ_CMD, mtc_null_rsp, MTC_NOT_SUPPORTED},
  689. /*ETA command */
  690. {MTC_KEY_EVENT_UNIV_REQ_CMD, mtc_null_rsp, MTC_NOT_SUPPORTED},
  691. {MTC_MEMORY_DUMP, mtc_null_rsp, MTC_NOT_SUPPORTED},
  692. {MTC_BATTERY_POWER, NULL, MTC_ARM9_PROCESSOR},
  693. {MTC_BACKLIGHT_INFO, mtc_null_rsp, MTC_NOT_SUPPORTED},
  694. {MTC_FLASH_MODE, mtc_null_rsp, MTC_NOT_SUPPORTED},
  695. {MTC_MODEM_MODE, mtc_null_rsp, MTC_NOT_SUPPORTED},
  696. {MTC_CELL_INFORMATION, mtc_null_rsp, MTC_NOT_SUPPORTED},
  697. {MTC_HANDOVER, mtc_null_rsp, MTC_NOT_SUPPORTED},
  698. {MTC_ERROR_CMD, mtc_null_rsp, MTC_NOT_SUPPORTED},
  699. {MTC_MAX_CMD, mtc_null_rsp, MTC_NOT_SUPPORTED},
  700. };