e24_host_linux.c 3.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162
  1. /*********************************Copyright (c)*********************************************
  2. **
  3. **
  4. **
  5. **-------------------------------file info-------------------------------------------------
  6. ** Vrsions: V1.0
  7. ** Filename: e24_host_linux.c
  8. ** Creator: shanlong.li
  9. ** Date: 2021/08/30
  10. ** Description: share memory and mailbox
  11. **
  12. **-------------------------------history----------------------------------------------
  13. ** Name: shanlong.li
  14. ** Versions: V1.0
  15. ** Date: 2021/08/30
  16. ** Description:
  17. **
  18. ** ----------------------------------------------------------------------------------------
  19. ******************************************************************************************/
  20. #include <stdio.h>
  21. #include <fcntl.h>
  22. #include <sys/ioctl.h>
  23. #include <sys/types.h>
  24. #include <unistd.h>
  25. #include <signal.h>
  26. #include "e24_host_shm.h"
  27. void e24_request_process(struct e24_device *device,
  28. struct e24_ioctl_user *data,enum e24_status *status);
  29. volatile int msg_done = 0;
  30. void e24_irq_handler(int val)
  31. {
  32. printf("e24 msg recv %d\n",val);
  33. msg_done = 1;
  34. }
  35. void init_signal(int fd)
  36. {
  37. int flags,ret;
  38. signal(SIGIO, e24_irq_handler);
  39. ret = fcntl(fd, F_SETOWN, getpid());
  40. flags = fcntl(fd, F_GETFL);
  41. fcntl(fd, F_SETFL, flags | FASYNC);
  42. }
  43. struct e24_device *e24_open_device(int idx, enum e24_status *status)
  44. {
  45. struct e24_device *device;
  46. char name[sizeof("/dev/eboot")+sizeof(int)*4];
  47. int fd;
  48. sprintf(name,"/dev/eboot%u",idx);
  49. fd = open(name,O_RDWR);
  50. if(fd < 0) {
  51. set_status(status,E24_STATUS_FAILURE);
  52. return NULL;
  53. }
  54. device = alloc_refcounted(sizeof(*device));
  55. if(!device) {
  56. set_status(status,E24_STATUS_FAILURE);
  57. return NULL;
  58. }
  59. device->fd = fd;
  60. set_status(status, E24_STATUS_SUCCESS);
  61. return device;
  62. }
  63. void e24_release_device(struct e24_device *device) {
  64. if(device) {
  65. close(device->fd);
  66. free(device);
  67. }
  68. }
  69. struct e24_event *e24_event_init(struct e24_device *device,enum e24_status *status) {
  70. struct e24_event *evt;
  71. evt = malloc(sizeof(*evt));
  72. if(!evt) {
  73. set_status(status,E24_STATUS_FAILURE);
  74. return NULL;
  75. }
  76. evt->device = device;
  77. evt->f_ops.fn = e24_request_process;
  78. return evt;
  79. }
  80. void e24_event_release(struct e24_event *evt) {
  81. ioctl(evt->device->fd,E24_IOCTL_FREE_CHANNEL,NULL);
  82. free(evt);
  83. }
  84. void e24_request_process(struct e24_device *device,
  85. struct e24_ioctl_user *data,enum e24_status *status) {
  86. int ret;
  87. data->flags = 4;
  88. ret = ioctl(device->fd,E24_IOCTL_GET_CHANNEL,NULL);
  89. ret = ioctl(device->fd,E24_IOCTL_SEND,data);
  90. if(ret < 0)
  91. set_status(status,E24_STATUS_FAILURE);
  92. else
  93. set_status(status, E24_STATUS_SUCCESS);
  94. }
  95. int e24_alloc_buffer(struct e24_device *device,
  96. struct e24_ioctl_alloc *alloc_buf,enum e24_status *status) {
  97. int ret;
  98. ret = ioctl(device->fd,E24_IOCTL_ALLOC,alloc_buf);
  99. if(ret < 0)
  100. set_status(status,E24_STATUS_FAILURE);
  101. else
  102. set_status(status, E24_STATUS_SUCCESS);
  103. return 0;
  104. }
  105. void e24_release_buffer(struct e24_device * device,struct e24_ioctl_alloc *alloc_buf) {
  106. if(alloc_buf)
  107. ioctl(device->fd,E24_IOCTL_FREE,alloc_buf);
  108. }
  109. void e24_run_push(struct e24_event *evt,struct e24_ioctl_user *user_data, enum e24_status *status) {
  110. evt->f_ops.fn(evt->device,user_data,status);
  111. }
  112. void e24_run_command(struct e24_event *evt, void *in_data, size_t in_data_size,
  113. void *out_data, size_t out_data_size, enum e24_status *status) {
  114. struct e24_ioctl_user *user_data;
  115. user_data = malloc(sizeof(*user_data));
  116. if(!user_data) {
  117. set_status(status, E24_STATUS_FAILURE);
  118. return;
  119. }
  120. user_data->in_data_addr = (_u64)in_data;
  121. user_data->in_data_size = in_data_size;
  122. user_data->out_data_addr = (_u64)out_data;
  123. user_data->out_data_size = out_data_size;
  124. e24_run_push(evt,user_data,status);
  125. free(user_data);
  126. }