isp_run_bm_script.c 7.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297
  1. /*
  2. * Copyright (C) 2021 Alibaba Group Holding Limited
  3. * Author: LuChongzhi <chongzhi.lcz@alibaba-inc.com>
  4. *
  5. * This program is free software; you can redistribute it and/or modify
  6. * it under the terms of the GNU General Public License version 2 as
  7. * published by the Free Software Foundation.
  8. */
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <unistd.h>
  12. #include <string.h>
  13. #include <errno.h>
  14. #include <sys/ioctl.h>
  15. #include <fcntl.h>
  16. #include <poll.h>
  17. #include <stdint.h>
  18. #include <ctype.h>
  19. #include "bm_isp_ioctl.h"
  20. #include "log_common.h"
  21. #define DEV_PATHNAME "/dev/bm_isp0"
  22. #define TOOL_NAME "isp_run_bm_script"
  23. #define INVALID_MAGIC32 0xDEADBEEF
  24. typedef enum {
  25. ISP_BM_SCRIPT_OP_REG_SET,
  26. ISP_BM_SCRIPT_OP_REG_GET,
  27. ISP_BM_SCRIPT_OP_MSLEEP,
  28. } isp_bm_script_op;
  29. typedef struct _isp_ctx {
  30. int dev_fd;
  31. } isp_ctx_t;
  32. static isp_ctx_t isp_ctx;
  33. typedef struct {
  34. isp_bm_script_op op;
  35. struct bm_isp_reg_t reg;
  36. unsigned int expect;
  37. unsigned int msleep;
  38. } isp_bm_script_info;
  39. typedef struct {
  40. uint32_t begin_line; // default:0
  41. uint32_t end_line; // default:-1, -1 means no limit
  42. char device_name[256];
  43. char bm_script_name[256];
  44. uint32_t simulate;
  45. } cmd_param_s;
  46. static int isp_init(isp_ctx_t *ctx, char *device_name)
  47. {
  48. int fd;
  49. if (!device_name) {
  50. printf("%s:device name is invalid\n", __func__);
  51. return -1;
  52. }
  53. memset(&isp_ctx, 0, sizeof(isp_ctx));
  54. fd = open(device_name, O_RDWR | O_NONBLOCK);
  55. if (fd < 0) {
  56. printf("%s:Can't open %s: %d(%s)\n", __func__,
  57. device_name, errno, strerror(errno));
  58. return -1;
  59. }
  60. ctx->dev_fd = fd;
  61. return 0;
  62. }
  63. static int isp_deinit(isp_ctx_t *ctx)
  64. {
  65. if (ctx->dev_fd >= 0) {
  66. close(ctx->dev_fd);
  67. ctx->dev_fd = -1;
  68. }
  69. return 0;
  70. }
  71. static int isp_ioctl(isp_ctx_t *ctx, unsigned int cmd, void *args)
  72. {
  73. int ret;
  74. if (ctx == NULL || ctx->dev_fd < 0) {
  75. printf("%s:ctx is invalid\n", __func__);
  76. return -1;
  77. }
  78. ret = ioctl(ctx->dev_fd, cmd, args);
  79. if (ret != 0) {
  80. printf("%s:ioctl failed, ret=%d(%s)\n", __func__,
  81. ret, strerror(ret * -1));
  82. return ret;
  83. }
  84. return 0;
  85. }
  86. static int parse_script_line(isp_bm_script_info *script_info, char *script_line)
  87. {
  88. int ret;
  89. char op_str[64]="";
  90. //printf("script_line=%s", script_line);
  91. ret = sscanf(script_line, "%s %x %x", op_str, &script_info->reg.offset, &script_info->reg.value);
  92. if (ret == 3 && (strcmp(op_str, "set") == 0 || strcmp(op_str, "0") == 0)) {
  93. script_info->op = ISP_BM_SCRIPT_OP_REG_SET;
  94. return 0;
  95. } else if (ret >= 2 && (strcmp(op_str, "get") == 0 || strcmp(op_str, "1") == 0)) {
  96. script_info->op = ISP_BM_SCRIPT_OP_REG_GET;
  97. if (ret == 2)
  98. script_info->expect = INVALID_MAGIC32;
  99. else
  100. script_info->expect = script_info->reg.value;
  101. return 0;
  102. } else if (ret == 2 && strcmp(op_str, "msleep") == 0) {
  103. ret = sscanf(script_line, "%s %d", op_str, &script_info->msleep);
  104. script_info->op = ISP_BM_SCRIPT_OP_MSLEEP;
  105. return 0;
  106. } else {
  107. printf_red("script_line invalid:'%s'\n", script_line);
  108. return -1;
  109. }
  110. }
  111. static void help(void)
  112. {
  113. printf("usage: %s [-d device] [-f script_file] [-s simulate]\n", TOOL_NAME);
  114. printf(" example: %s -d /dev/isp0 -f isp_bm_scripts/isp_v4_mcm.txt -b 0 -e 9 -s 0\n", TOOL_NAME);
  115. }
  116. static void _dump_cmd_param(cmd_param_s *cmd_param)
  117. {
  118. printf("%s -d %s -f %s -b %d -e %d -s %d\n",
  119. TOOL_NAME,
  120. cmd_param->device_name,
  121. cmd_param->bm_script_name,
  122. cmd_param->begin_line,
  123. cmd_param->end_line,
  124. cmd_param->simulate);
  125. }
  126. static int parse_cmd_params(int argc,char *argv[], cmd_param_s *cmd_param)
  127. {
  128. int param_cnt = 1;
  129. memset(cmd_param, 0, sizeof(*cmd_param));
  130. cmd_param->begin_line = 0;
  131. cmd_param->end_line = -1;
  132. if (argc == 1) {
  133. help();
  134. return -1;
  135. }
  136. while (param_cnt < argc) {
  137. if (0 == strncmp (argv[param_cnt], "-d", 2)) {
  138. strncpy(cmd_param->device_name, argv[param_cnt+1], sizeof(cmd_param->bm_script_name));
  139. param_cnt += 2;
  140. } else if (0 == strncmp (argv[param_cnt], "-f", 2)) {
  141. strncpy(cmd_param->bm_script_name, argv[param_cnt+1], sizeof(cmd_param->bm_script_name));
  142. param_cnt += 2;
  143. } else if (0 == strncmp (argv[param_cnt], "-b", 2)) {
  144. cmd_param->begin_line = atoi(argv[param_cnt+1]);
  145. param_cnt += 2;
  146. } else if (0 == strncmp (argv[param_cnt], "-e", 2)) {
  147. cmd_param->end_line = atoi(argv[param_cnt+1]);
  148. param_cnt += 2;
  149. } else if (0 == strncmp (argv[param_cnt], "-s", 2)) {
  150. cmd_param->simulate = atoi(argv[param_cnt+1]);
  151. param_cnt += 2;
  152. } else {
  153. printf("Invalid syntax.\n");
  154. _dump_cmd_param(cmd_param);
  155. help();
  156. return -1;
  157. }
  158. }
  159. return 0;
  160. }
  161. int main(int argc, char *argv[])
  162. {
  163. int32_t ret = 0;
  164. uint32_t current_line = 0;
  165. uint32_t run_lines = 0;
  166. FILE *stream;
  167. char string[1024];
  168. cmd_param_s cmd_param;
  169. ret = parse_cmd_params(argc, argv, &cmd_param);
  170. if (ret != 0) {
  171. return ret;
  172. }
  173. _dump_cmd_param(&cmd_param);
  174. if (cmd_param.simulate == 0) {
  175. ret = isp_init(&isp_ctx, &(cmd_param.device_name[0]));
  176. if (ret != 0) {
  177. printf("isp_init failed\n");
  178. exit(ret);
  179. }
  180. }
  181. stream = fopen(cmd_param.bm_script_name, "r");
  182. if(stream == NULL) {
  183. printf("Open script file:'%s' failed\n", cmd_param.bm_script_name);
  184. return -1;
  185. }
  186. printf(">>> Below result is run under %s:\n",
  187. cmd_param.simulate ? "Simulation" : "Hardware");
  188. fseek(stream, 0, SEEK_SET);
  189. while (current_line <= cmd_param.end_line) {
  190. if (fgets(string, sizeof(string), stream) == NULL) {
  191. //printf("fgets script file:'%s' failed\n", cmd_param.bm_script_name);
  192. break;
  193. }
  194. if (current_line >= cmd_param.begin_line &&
  195. current_line <= cmd_param.end_line) {
  196. //struct bm_isp_reg_t reg;
  197. isp_bm_script_info script_info;
  198. ret = parse_script_line(&script_info, string);
  199. if (ret != 0) {
  200. //printf_red("Line-%03d is invalid:%s", current_line+1, string);
  201. current_line++;
  202. continue;
  203. }
  204. //printf("[line-%03d] offset=0x%08x, value=0x%08x\n",
  205. // current_line, reg.offset, reg.value);
  206. if (cmd_param.simulate == 0) {
  207. if (script_info.op == ISP_BM_SCRIPT_OP_REG_SET) {
  208. ret = isp_ioctl(&isp_ctx, BMISPIOC_WRITE_REG, &script_info.reg);
  209. if (ret == 0) {
  210. printf("line%03d: Write reg OK, offset=0x%08x, value=0x%08x\n",
  211. current_line+1, script_info.reg.offset, script_info.reg.value);
  212. } else {
  213. printf("line%03d: Write reg failed\n", current_line+1);
  214. ret = -1;
  215. break;
  216. }
  217. } else if (script_info.op == ISP_BM_SCRIPT_OP_REG_GET) {
  218. ret = isp_ioctl(&isp_ctx, BMISPIOC_READ_REG, &script_info.reg);
  219. if (ret == 0) {
  220. printf("line%03d: Read reg OK, offset=0x%08x, value=0x%08x\n",
  221. current_line+1, script_info.reg.offset, script_info.reg.value);
  222. } else {
  223. printf("line%03d: Read reg failed\n", current_line+1);
  224. ret = -1;
  225. break;
  226. }
  227. if (script_info.expect != INVALID_MAGIC32 &&
  228. script_info.reg.value != script_info.expect) {
  229. printf_red(" Read value(0x%08x) != expect(0x%08x)\n",
  230. script_info.reg.value, script_info.expect);
  231. }
  232. } else if (script_info.op == ISP_BM_SCRIPT_OP_MSLEEP) {
  233. usleep(script_info.msleep * 1000);
  234. printf("line%03d: sleep %ums finished\n", current_line+1, script_info.msleep);
  235. }
  236. } else {
  237. if (script_info.op == ISP_BM_SCRIPT_OP_REG_SET) {
  238. printf("line%03d: Write reg OK, offset=0x%08x, value=0x%08x\n",
  239. current_line+1, script_info.reg.offset, script_info.reg.value);
  240. } else if (script_info.op == ISP_BM_SCRIPT_OP_REG_GET) {
  241. printf("line%03d: Read reg OK, offset=0x%08x, value=0x%08x\n",
  242. current_line+1, script_info.reg.offset,script_info.reg.value);
  243. if (script_info.expect != INVALID_MAGIC32 &&
  244. script_info.reg.value != script_info.expect) {
  245. printf_red(" Read value(0x%08x) != expect(0x%08x)\n",
  246. script_info.reg.value, script_info.expect);
  247. }
  248. } else if (script_info.op == ISP_BM_SCRIPT_OP_MSLEEP) {
  249. usleep(script_info.msleep * 1000);
  250. printf("line%03d: sleep %ums finished\n", current_line+1, script_info.msleep);
  251. }
  252. }
  253. }
  254. run_lines++;
  255. current_line++;
  256. }
  257. printf("<<< %d script lines are run\n", run_lines);
  258. if (cmd_param.simulate == 0) {
  259. isp_deinit(&isp_ctx);
  260. }
  261. fclose(stream);
  262. return 0;
  263. }