flash_led_sysfs.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415
  1. #include "flash_led_driver.h"
  2. #include "flash_led_ioctl.h"
  3. extern uint64_t touch_pin_int_num(struct flash_led_ctrl *pflash_led_dev);
  4. extern uint64_t touch_pin_high_time_us(void);
  5. extern uint64_t touch_pin_preiod_time_us(void);
  6. extern uint64_t touch_pin_falling_int(void);
  7. extern uint64_t touch_pin_rising_int(void);
  8. static ssize_t flash_led_falling_int_show(struct device *dev,
  9. struct device_attribute *attr, char *buf)
  10. {
  11. char buffer[100];
  12. printk("<0>""flash_led falling interrupt num: %d\n", touch_pin_falling_int());
  13. snprintf(buffer, sizeof(buffer), "falling num :%llu\n", touch_pin_falling_int());
  14. return strlcpy(buf, buffer, PAGE_SIZE);
  15. }
  16. static ssize_t flash_led_rising_int_show(struct device *dev,
  17. struct device_attribute *attr, char *buf)
  18. {
  19. char buffer[100];
  20. printk("<0>""flash_led rising interrupt num: %d\n", touch_pin_rising_int());
  21. snprintf(buffer, sizeof(buffer), "rising interupt num :%llu\n", touch_pin_rising_int());
  22. return strlcpy(buf, buffer, PAGE_SIZE);
  23. }
  24. static ssize_t flash_led_info_show(struct device *dev,
  25. struct device_attribute *attr, char *buf)
  26. {
  27. struct platform_device *pdev = to_platform_device(dev);
  28. struct flash_led_driver_dev *pdriver_dev;
  29. struct flash_led_ctrl *pflash_led_dev;
  30. struct flash_led_dev *floodlight;
  31. struct flash_led_dev *projection;
  32. char buffer[200];
  33. char name1[30] = {0};
  34. char name2[30] = {0};
  35. pdriver_dev = platform_get_drvdata(pdev);
  36. pflash_led_dev = (struct flash_led_ctrl*)pdriver_dev->private;
  37. floodlight = &pflash_led_dev->floodlight;
  38. projection = &pflash_led_dev->projection;
  39. if (floodlight->flash_led_func != NULL) {
  40. strcpy(name1, floodlight->flash_led_func->flash_led_name);
  41. }
  42. if (projection->flash_led_func != NULL) {
  43. strcpy(name2, projection->flash_led_func->flash_led_name);
  44. }
  45. snprintf(buffer, sizeof(buffer), "f_led_%s i2c is :%d, p_led_%s i2c is %d\n",
  46. name1,
  47. floodlight->i2c_bus,
  48. name2,
  49. projection->i2c_bus);
  50. return strlcpy(buf, buffer, PAGE_SIZE);
  51. }
  52. static ssize_t flash_led_int_show(struct device *dev,
  53. struct device_attribute *attr, char *buf)
  54. {
  55. struct platform_device *pdev = to_platform_device(dev);
  56. struct flash_led_driver_dev *pdriver_dev;
  57. struct flash_led_ctrl *pflash_led_dev;
  58. pdriver_dev = platform_get_drvdata(pdev);
  59. pflash_led_dev = (struct flash_led_ctrl*)pdriver_dev->private;
  60. char buffer[100];
  61. printk("<0>""flash_led interrupt num: %d\n", touch_pin_int_num(pflash_led_dev));
  62. snprintf(buffer, sizeof(buffer), "interupt num :%llu\n", touch_pin_int_num(pflash_led_dev));
  63. return strlcpy(buf, buffer, PAGE_SIZE);
  64. }
  65. static ssize_t flash_led_pin_high_time_us_show(struct device *dev,
  66. struct device_attribute *attr, char *buf)
  67. {
  68. char buffer[100];
  69. snprintf(buffer, sizeof(buffer), "h time us is :%llu\n", touch_pin_high_time_us());
  70. return strlcpy(buf, buffer, PAGE_SIZE);
  71. }
  72. static ssize_t flash_led_pin_period_us_show(struct device *dev,
  73. struct device_attribute *attr, char *buf)
  74. {
  75. char buffer[100];
  76. snprintf(buffer, sizeof(buffer), "preiod us is :%llu\n", touch_pin_preiod_time_us());
  77. return strlcpy(buf, buffer, PAGE_SIZE);
  78. }
  79. int32_t flash_led_i2c_write(struct flash_led_dev *dev, uint32_t address, uint32_t data);
  80. int32_t flash_led_i2c_read(struct flash_led_dev *dev, uint32_t address, uint32_t *pdata);
  81. static ssize_t floodlight_led_reg_read_store(struct device *dev,
  82. struct device_attribute *attr,
  83. const char *buf,
  84. size_t count)
  85. {
  86. int ret = 0;
  87. struct platform_device *pdev = to_platform_device(dev);
  88. struct flash_led_driver_dev *pdriver_dev;
  89. struct flash_led_ctrl *pflash_led_dev;
  90. struct flash_led_dev *floodlight;
  91. unsigned long addr;
  92. uint32_t val;
  93. pdriver_dev = platform_get_drvdata(pdev);
  94. pflash_led_dev = (struct flash_led_ctrl*)pdriver_dev->private;
  95. floodlight = &pflash_led_dev->floodlight;
  96. if(floodlight->i2c_bus == UNDEFINED_IN_DTS) {
  97. return count;
  98. }
  99. ret = kstrtoul(buf, 16, &addr);
  100. if (ret < 0) {
  101. return ret;
  102. }
  103. ret = flash_led_i2c_read(floodlight, addr, &val);
  104. if (ret < 0) {
  105. return ret;
  106. }
  107. printk("read reg[0x%x]: 0x%x\n", addr, val);
  108. return count;
  109. }
  110. static ssize_t floodlight_led_reg_write_store(struct device *dev,
  111. struct device_attribute *attr,
  112. const char *buf,
  113. size_t count)
  114. {
  115. int ret = 0;
  116. struct platform_device *pdev = to_platform_device(dev);
  117. struct flash_led_driver_dev *pdriver_dev;
  118. struct flash_led_ctrl *pflash_led_dev;
  119. struct flash_led_dev *floodlight;
  120. char buffer[100];
  121. unsigned long addr;
  122. uint32_t val;
  123. pdriver_dev = platform_get_drvdata(pdev);
  124. pflash_led_dev = (struct flash_led_ctrl*)pdriver_dev->private;
  125. floodlight = &pflash_led_dev->floodlight;
  126. if(floodlight->i2c_bus == UNDEFINED_IN_DTS) {
  127. return count;
  128. }
  129. ret = kstrtoul(buf, 16, &addr);
  130. if (ret < 0) {
  131. return ret;
  132. }
  133. val = addr & 0xff;
  134. addr = addr >> 8;
  135. ret = flash_led_i2c_write(floodlight, addr, val);
  136. if (ret < 0) {
  137. return ret;
  138. }
  139. printk("write reg[0x%x] 0x%x\n", addr, val);
  140. return count;
  141. }
  142. static ssize_t projection_led_reg_read_store(struct device *dev,
  143. struct device_attribute *attr,
  144. const char *buf,
  145. size_t count)
  146. {
  147. int ret = 0;
  148. struct platform_device *pdev = to_platform_device(dev);
  149. struct flash_led_driver_dev *pdriver_dev;
  150. struct flash_led_ctrl *pflash_led_dev;
  151. struct flash_led_dev *projection;
  152. unsigned long addr;
  153. uint32_t val;
  154. pdriver_dev = platform_get_drvdata(pdev);
  155. pflash_led_dev = (struct flash_led_ctrl*)pdriver_dev->private;
  156. projection = &pflash_led_dev->projection;
  157. if(projection->i2c_bus == UNDEFINED_IN_DTS) {
  158. return count;
  159. }
  160. ret = kstrtoul(buf, 16, &addr);
  161. if (ret < 0) {
  162. return ret;
  163. }
  164. ret = flash_led_i2c_read(projection, addr, &val);
  165. if (ret < 0) {
  166. return ret;
  167. }
  168. printk("read reg[0x%x]: 0x%x\n", addr, val);
  169. return count;
  170. }
  171. static ssize_t projection_led_reg_write_store(struct device *dev,
  172. struct device_attribute *attr,
  173. const char *buf,
  174. size_t count)
  175. {
  176. int ret = 0;
  177. struct platform_device *pdev = to_platform_device(dev);
  178. struct flash_led_driver_dev *pdriver_dev;
  179. struct flash_led_ctrl *pflash_led_dev;
  180. struct flash_led_dev *projection;
  181. char buffer[100];
  182. unsigned long addr;
  183. uint32_t val;
  184. pdriver_dev = platform_get_drvdata(pdev);
  185. pflash_led_dev = (struct flash_led_ctrl*)pdriver_dev->private;
  186. projection = &pflash_led_dev->projection;
  187. if(projection->i2c_bus == UNDEFINED_IN_DTS) {
  188. return count;
  189. }
  190. ret = kstrtoul(buf, 16, &addr);
  191. if (ret < 0) {
  192. return ret;
  193. }
  194. val = addr & 0xff;
  195. addr = addr >> 8;
  196. ret = flash_led_i2c_write(projection, addr, val);
  197. if (ret < 0) {
  198. return ret;
  199. }
  200. printk("write reg[0x%x] 0x%x\n", addr, val);
  201. return count;
  202. }
  203. static ssize_t flash_led_enable_store(struct device *dev,
  204. struct device_attribute *attr,
  205. const char *buf,
  206. size_t count)
  207. {
  208. int ret = 0;
  209. struct platform_device *pdev = to_platform_device(dev);
  210. struct flash_led_driver_dev *pdriver_dev;
  211. struct flash_led_ctrl *pflash_led_dev;
  212. char buffer[100];
  213. unsigned long en;
  214. pdriver_dev = platform_get_drvdata(pdev);
  215. pflash_led_dev = (struct flash_led_ctrl *)pdriver_dev->private;
  216. ret = kstrtoul(buf, 10, &en);
  217. if (ret < 0) {
  218. return ret;
  219. }
  220. pflash_led_dev->enable = en;
  221. return count;
  222. }
  223. static ssize_t flash_led_enable_show(struct device *dev,
  224. struct device_attribute *attr, char *buf)
  225. {
  226. int ret = 0;
  227. struct platform_device *pdev = to_platform_device(dev);
  228. struct flash_led_driver_dev *pdriver_dev;
  229. struct flash_led_ctrl *pflash_led_dev;
  230. char buffer[100];
  231. unsigned long en;
  232. pdriver_dev = platform_get_drvdata(pdev);
  233. pflash_led_dev = (struct flash_led_ctrl *)pdriver_dev->private;
  234. snprintf(buffer, sizeof(buffer), "flash_led enable mask is 0x%x\n", pflash_led_dev->enable);
  235. return strlcpy(buf, buffer, PAGE_SIZE);
  236. }
  237. uint64_t get_us_time(void);
  238. static ssize_t projection_enable_store(struct device *dev,
  239. struct device_attribute *attr,
  240. const char *buf,
  241. size_t count)
  242. {
  243. int ret = 0;
  244. struct platform_device *pdev = to_platform_device(dev);
  245. struct flash_led_driver_dev *pdriver_dev;
  246. struct flash_led_ctrl *pflash_led_dev;
  247. struct flash_led_dev *projection;
  248. char buffer[100];
  249. unsigned long ch;
  250. pdriver_dev = platform_get_drvdata(pdev);
  251. pflash_led_dev = (struct flash_led_ctrl*)pdriver_dev->private;
  252. projection = &pflash_led_dev->projection;
  253. ret = kstrtoul(buf, 10, &ch);
  254. if (ret < 0) {
  255. return ret;
  256. }
  257. uint64_t us1 = get_us_time();
  258. if (projection->flash_led_func != NULL) {
  259. projection->flash_led_func->enable_channel(projection, ch);
  260. }
  261. uint64_t us2 = get_us_time();
  262. printk("used time %llu us\n", us2 - us1);
  263. return count;
  264. }
  265. static ssize_t floodlight_enable_store(struct device *dev,
  266. struct device_attribute *attr,
  267. const char *buf,
  268. size_t count)
  269. {
  270. int ret = 0;
  271. struct platform_device *pdev = to_platform_device(dev);
  272. struct flash_led_driver_dev *pdriver_dev;
  273. struct flash_led_ctrl *pflash_led_dev;
  274. struct flash_led_dev *floodlight;
  275. unsigned long ch;
  276. pdriver_dev = platform_get_drvdata(pdev);
  277. pflash_led_dev = (struct flash_led_ctrl*)pdriver_dev->private;
  278. floodlight = &pflash_led_dev->floodlight;
  279. ret = kstrtoul(buf, 10, &ch);
  280. if (ret < 0) {
  281. return ret;
  282. }
  283. uint64_t us1 = get_us_time();
  284. if (floodlight->flash_led_func != NULL) {
  285. floodlight->flash_led_func->enable_channel(floodlight, ch);
  286. }
  287. uint64_t us2 = get_us_time();
  288. printk("used time %llu us\n", us2 - us1);
  289. return count;
  290. }
  291. static DEVICE_ATTR_RO(flash_led_info);
  292. static DEVICE_ATTR_RO(flash_led_int);
  293. static DEVICE_ATTR_RO(flash_led_pin_high_time_us);
  294. static DEVICE_ATTR_RO(flash_led_pin_period_us);
  295. static DEVICE_ATTR_RO(flash_led_falling_int);
  296. static DEVICE_ATTR_RO(flash_led_rising_int);
  297. static DEVICE_ATTR_WO(projection_led_reg_write);
  298. static DEVICE_ATTR_WO(projection_led_reg_read);
  299. static DEVICE_ATTR_WO(floodlight_led_reg_write);
  300. static DEVICE_ATTR_WO(floodlight_led_reg_read);
  301. static DEVICE_ATTR_WO(projection_enable);
  302. static DEVICE_ATTR_WO(floodlight_enable);
  303. static DEVICE_ATTR_RW(flash_led_enable);
  304. int flash_led_create_capabilities_sysfs(struct platform_device *pdev)
  305. {
  306. device_create_file(&pdev->dev, &dev_attr_flash_led_info);
  307. device_create_file(&pdev->dev, &dev_attr_flash_led_int);
  308. device_create_file(&pdev->dev, &dev_attr_flash_led_pin_high_time_us);
  309. device_create_file(&pdev->dev, &dev_attr_flash_led_pin_period_us);
  310. device_create_file(&pdev->dev, &dev_attr_flash_led_falling_int);
  311. device_create_file(&pdev->dev, &dev_attr_flash_led_rising_int);
  312. device_create_file(&pdev->dev, &dev_attr_projection_led_reg_write);
  313. device_create_file(&pdev->dev, &dev_attr_projection_led_reg_read);
  314. device_create_file(&pdev->dev, &dev_attr_floodlight_led_reg_write);
  315. device_create_file(&pdev->dev, &dev_attr_floodlight_led_reg_read);
  316. device_create_file(&pdev->dev, &dev_attr_projection_enable);
  317. device_create_file(&pdev->dev, &dev_attr_floodlight_enable);
  318. device_create_file(&pdev->dev, &dev_attr_flash_led_enable);
  319. return 0;
  320. }
  321. int flash_led_remove_capabilities_sysfs(struct platform_device *pdev)
  322. {
  323. device_remove_file(&pdev->dev, &dev_attr_flash_led_info);
  324. device_remove_file(&pdev->dev, &dev_attr_flash_led_int);
  325. device_remove_file(&pdev->dev, &dev_attr_flash_led_pin_high_time_us);
  326. device_remove_file(&pdev->dev, &dev_attr_flash_led_pin_period_us);
  327. device_remove_file(&pdev->dev, &dev_attr_flash_led_falling_int);
  328. device_remove_file(&pdev->dev, &dev_attr_flash_led_rising_int);
  329. device_remove_file(&pdev->dev, &dev_attr_projection_led_reg_write);
  330. device_remove_file(&pdev->dev, &dev_attr_projection_led_reg_read);
  331. device_remove_file(&pdev->dev, &dev_attr_floodlight_led_reg_write);
  332. device_remove_file(&pdev->dev, &dev_attr_floodlight_led_reg_read);
  333. device_remove_file(&pdev->dev, &dev_attr_projection_enable);
  334. device_remove_file(&pdev->dev, &dev_attr_floodlight_enable);
  335. device_remove_file(&pdev->dev, &dev_attr_flash_led_enable);
  336. return 0;
  337. }