shared_memory.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391
  1. /*
  2. * =====================================================================================
  3. *
  4. * ________ .__ __ ________ ____ ________
  5. * \_____ \ __ __|__| ____ | | __\______ \ _______ _/_ |/ _____/
  6. * / / \ \| | \ |/ ___\| |/ / | | \_/ __ \ \/ /| / __ \
  7. * / \_/. \ | / \ \___| < | ` \ ___/\ / | \ |__\ \
  8. * \_____\ \_/____/|__|\___ >__|_ \/_______ /\___ >\_/ |___|\_____ /
  9. * \__> \/ \/ \/ \/ \/
  10. *
  11. * www.optixx.org
  12. *
  13. *
  14. * Version: 1.0
  15. * Created: 07/21/2009 03:32:16 PM
  16. * Author: david@optixx.org
  17. *
  18. * =====================================================================================
  19. */
  20. #include <stdlib.h>
  21. #include <stdint.h>
  22. #include <util/delay.h>
  23. #include "shared_memory.h"
  24. #include "config.h"
  25. #include "sram.h"
  26. #include "debug.h"
  27. #include "dump.h"
  28. #include "info.h"
  29. #include "crc.h"
  30. uint8_t irq_addr_lo;
  31. uint8_t irq_addr_hi;
  32. uint8_t scratchpad_state;
  33. uint8_t scratchpad_cmd;
  34. uint8_t scratchpad_payload;
  35. uint8_t scratchpad_region_rx[SHARED_MEM_RX_LOC_SIZE];
  36. uint8_t scratchpad_region_tx[SHARED_MEM_TX_LOC_SIZE];
  37. uint8_t scratchpad_locked_rx = 1;
  38. uint8_t scratchpad_locked_tx = 1;
  39. void shared_memory_init(void)
  40. {
  41. scratchpad_locked_rx = 1;
  42. scratchpad_locked_tx = 1;
  43. }
  44. uint8_t shared_memory_scratchpad_region_save_helper(uint32_t addr)
  45. {
  46. #if DO_SHM_SCRATCHPAD
  47. if (addr > (SHARED_MEM_TX_LOC_STATE + (SHARED_MEM_TX_LOC_SIZE))
  48. && scratchpad_locked_tx) {
  49. debug_P(DEBUG_SHM,
  50. PSTR
  51. ("shared_memory_scratchpad_region_save_helper: open tx addr=0x%06lx\n"),
  52. addr);
  53. shared_memory_scratchpad_region_tx_save();
  54. return 0;
  55. }
  56. if (addr > (SHARED_MEM_RX_LOC_STATE + (SHARED_MEM_RX_LOC_SIZE))
  57. && scratchpad_locked_rx) {
  58. debug_P(DEBUG_SHM,
  59. PSTR
  60. ("shared_memory_scratchpad_region_save_helper: open rx addr=0x%06lx\n"),
  61. addr);
  62. shared_memory_scratchpad_region_rx_save();
  63. return 0;
  64. }
  65. #endif
  66. return 1;
  67. }
  68. void shared_memory_scratchpad_region_tx_save()
  69. {
  70. sram_bulk_addr_save();
  71. #if SHARED_SCRATCHPAD_CRC
  72. uint16_t crc;
  73. crc = crc_check_bulk_memory((uint32_t) SHARED_MEM_TX_LOC_STATE,
  74. (uint32_t) (SHARED_MEM_TX_LOC_STATE +
  75. SHARED_MEM_TX_LOC_SIZE), 0x8000);
  76. debug_P(DEBUG_SHM,
  77. PSTR("shared_memory_scratchpad_region_tx_save: crc=%x\n"), crc);
  78. #endif
  79. debug_P(DEBUG_SHM,
  80. PSTR("shared_memory_scratchpad_region_tx_save: unlock\n"));
  81. sram_bulk_copy_into_buffer((uint32_t) SHARED_MEM_TX_LOC_STATE,
  82. scratchpad_region_tx,
  83. (uint32_t) SHARED_MEM_TX_LOC_SIZE);
  84. scratchpad_locked_tx = 0;
  85. #if SHARED_SCRATCHPAD_CRC
  86. do_crc_update(0, scratchpad_region_tx, SHARED_MEM_TX_LOC_SIZE);
  87. debug_P(DEBUG_SHM,
  88. PSTR("shared_memory_scratchpad_region_tx_save: crc=%x\n"), crc);
  89. #endif
  90. #if SHARED_SCRATCHPAD_DUMP
  91. dump_packet(SHARED_MEM_TX_LOC_STATE, SHARED_MEM_TX_LOC_SIZE,
  92. scratchpad_region_tx);
  93. dump_memory(SHARED_MEM_TX_LOC_STATE,
  94. SHARED_MEM_TX_LOC_STATE + SHARED_MEM_TX_LOC_SIZE);
  95. #endif
  96. sram_bulk_addr_restore();
  97. }
  98. void shared_memory_scratchpad_region_rx_save()
  99. {
  100. sram_bulk_addr_save();
  101. #if SHARED_SCRATCHPAD_CRC
  102. uint16_t crc;
  103. crc = crc_check_bulk_memory((uint32_t) SHARED_MEM_RX_LOC_STATE,
  104. (uint32_t) (SHARED_MEM_RX_LOC_STATE +
  105. SHARED_MEM_RX_LOC_SIZE), 0x8000);
  106. debug_P(DEBUG_SHM,
  107. PSTR("shared_memory_scratchpad_region_rx_save: crc=%x\n"), crc);
  108. #endif
  109. debug_P(DEBUG_SHM,
  110. PSTR("shared_memory_scratchpad_region_rx_save: unlock\n"));
  111. sram_bulk_copy_into_buffer((uint32_t) SHARED_MEM_RX_LOC_STATE,
  112. scratchpad_region_rx,
  113. (uint32_t) SHARED_MEM_RX_LOC_SIZE);
  114. scratchpad_locked_rx = 0;
  115. #if SHARED_SCRATCHPAD_CRC
  116. do_crc_update(0, scratchpad_region_rx, SHARED_MEM_RX_LOC_SIZE);
  117. debug_P(DEBUG_SHM,
  118. PSTR("shared_memory_scratchpad_region_rx_save: crc=%x\n"), crc);
  119. #endif
  120. #if SHARED_SCRATCHPAD_DUMP
  121. dump_packet(SHARED_MEM_RX_LOC_STATE, SHARED_MEM_RX_LOC_SIZE,
  122. scratchpad_region_rx);
  123. dump_memory(SHARED_MEM_RX_LOC_STATE,
  124. SHARED_MEM_RX_LOC_STATE + SHARED_MEM_RX_LOC_SIZE);
  125. #endif
  126. sram_bulk_addr_restore();
  127. }
  128. void shared_memory_scratchpad_region_tx_restore()
  129. {
  130. if (scratchpad_locked_tx)
  131. return;
  132. debug_P(DEBUG_SHM,
  133. PSTR("shared_memory_scratchpad_region_tx_restore: lock\n"));
  134. #if SHARED_SCRATCHPAD_DUMP
  135. debug_P(DEBUG_SHM,
  136. PSTR("shared_memory_scratchpad_region_tx_restore: memory\n"));
  137. dump_memory(SHARED_MEM_TX_LOC_STATE,
  138. SHARED_MEM_TX_LOC_STATE + SHARED_MEM_TX_LOC_SIZE);
  139. #endif
  140. sram_bulk_copy_from_buffer((uint32_t) SHARED_MEM_TX_LOC_STATE,
  141. scratchpad_region_tx,
  142. (uint32_t) SHARED_MEM_TX_LOC_SIZE);
  143. scratchpad_locked_tx = 1;
  144. #if SHARED_SCRATCHPAD_DUMP
  145. debug_P(DEBUG_SHM,
  146. PSTR("shared_memory_scratchpad_region_tx_restore: buffer\n"));
  147. dump_packet(SHARED_MEM_TX_LOC_STATE, SHARED_MEM_TX_LOC_SIZE,
  148. scratchpad_region_tx);
  149. debug_P(DEBUG_SHM,
  150. PSTR("shared_memory_scratchpad_region_tx_restore: memory\n"));
  151. dump_memory(SHARED_MEM_TX_LOC_STATE,
  152. SHARED_MEM_TX_LOC_STATE + SHARED_MEM_TX_LOC_SIZE);
  153. #endif
  154. #if SHARED_SCRATCHPAD_CRC
  155. uint16_t crc;
  156. crc = crc_check_bulk_memory((uint32_t) SHARED_MEM_TX_LOC_STATE,
  157. (uint32_t) (SHARED_MEM_TX_LOC_STATE +
  158. SHARED_MEM_TX_LOC_SIZE), 0x8000);
  159. debug_P(DEBUG_SHM,
  160. PSTR("shared_memory_scratchpad_region_tx_restore: crc=%x\n"), crc);
  161. #endif
  162. }
  163. void shared_memory_scratchpad_region_rx_restore()
  164. {
  165. if (scratchpad_locked_rx)
  166. return;
  167. debug_P(DEBUG_SHM,
  168. PSTR("shared_memory_scratchpad_region_rx_restore: lock\n"));
  169. #if SHARED_SCRATCHPAD_DUMP
  170. debug_P(DEBUG_SHM,
  171. PSTR("shared_memory_scratchpad_region_rx_restore: memory\n"));
  172. dump_memory(SHARED_MEM_RX_LOC_STATE - 0x10,
  173. SHARED_MEM_RX_LOC_STATE + SHARED_MEM_RX_LOC_SIZE);
  174. #endif
  175. sram_bulk_copy_from_buffer((uint32_t) SHARED_MEM_RX_LOC_STATE,
  176. scratchpad_region_rx,
  177. (uint32_t) SHARED_MEM_RX_LOC_SIZE);
  178. scratchpad_locked_rx = 1;
  179. #if SHARED_SCRATCHPAD_DUMP
  180. debug_P(DEBUG_SHM,
  181. PSTR("shared_memory_scratchpad_region_rx_restore: buffer\n"));
  182. dump_packet(SHARED_MEM_RX_LOC_STATE, SHARED_MEM_RX_LOC_SIZE,
  183. scratchpad_region_rx);
  184. debug_P(DEBUG_SHM,
  185. PSTR("shared_memory_scratchpad_region_rx_restore: memory\n"));
  186. dump_memory(SHARED_MEM_RX_LOC_STATE - 0x10,
  187. SHARED_MEM_RX_LOC_STATE + SHARED_MEM_RX_LOC_SIZE);
  188. #endif
  189. #if SHARED_SCRATCHPAD_CRC
  190. uint16_t crc;
  191. crc = crc_check_bulk_memory((uint32_t) SHARED_MEM_RX_LOC_STATE,
  192. (uint32_t) (SHARED_MEM_RX_LOC_STATE +
  193. SHARED_MEM_RX_LOC_SIZE), 0x8000);
  194. debug_P(DEBUG_SHM,
  195. PSTR("shared_memory_scratchpad_region_rx_restore: crc=%x\n"), crc);
  196. #endif
  197. }
  198. void shared_memory_scratchpad_tx_save()
  199. {
  200. scratchpad_state = sram_read(SHARED_MEM_TX_LOC_STATE);
  201. scratchpad_cmd = sram_read(SHARED_MEM_TX_LOC_CMD);
  202. scratchpad_payload = sram_read(SHARED_MEM_TX_LOC_PAYLOAD);
  203. }
  204. void shared_memory_scratchpad_tx_restore()
  205. {
  206. sram_write(SHARED_MEM_TX_LOC_STATE, scratchpad_state);
  207. sram_write(SHARED_MEM_TX_LOC_CMD, scratchpad_cmd);
  208. sram_write(SHARED_MEM_TX_LOC_PAYLOAD, scratchpad_payload);
  209. }
  210. void shared_memory_irq_hook()
  211. {
  212. irq_addr_lo = sram_read(SHARED_IRQ_LOC_LO);
  213. irq_addr_hi = sram_read(SHARED_IRQ_LOC_HI);
  214. sram_write(SHARED_IRQ_HANDLER_LO, 0);
  215. sram_write(SHARED_IRQ_HANDLER_HI, 0);
  216. }
  217. void shared_memory_irq_restore()
  218. {
  219. sram_write(SHARED_IRQ_LOC_LO, irq_addr_lo);
  220. sram_write(SHARED_IRQ_LOC_HI, irq_addr_hi);
  221. }
  222. void shared_memory_write(uint8_t cmd, uint8_t value)
  223. {
  224. #if DO_SHM
  225. #if DO_SHM_SCRATCHPAD
  226. if (scratchpad_locked_tx) {
  227. debug_P(DEBUG_SHM, PSTR("shared_memory_write: locked_tx\n"));
  228. return;
  229. }
  230. #endif
  231. debug_P(DEBUG_SHM,
  232. PSTR("shared_memory_write: 0x%04x=0x%02x 0x%04x=0x%02x \n"),
  233. SHARED_MEM_TX_LOC_CMD, cmd, SHARED_MEM_TX_LOC_PAYLOAD, value);
  234. sram_bulk_addr_save();
  235. #if (DO_SHM_SCRATCHPAD==0)
  236. shared_memory_scratchpad_tx_save();
  237. #endif
  238. #if SHARED_MEM_SWITCH_IRQ
  239. shared_memory_irq_hook();
  240. #endif
  241. sram_write(SHARED_MEM_TX_LOC_STATE, SHARED_MEM_TX_SNES_ACK);
  242. sram_write(SHARED_MEM_TX_LOC_CMD, cmd);
  243. sram_write(SHARED_MEM_TX_LOC_PAYLOAD, value);
  244. snes_hirom();
  245. snes_wr_disable();
  246. snes_bus_active();
  247. #if SHARED_MEM_SWITCH_IRQ
  248. snes_irq_on();
  249. snes_irq_lo();
  250. _delay_us(20);
  251. snes_irq_hi();
  252. snes_irq_off();
  253. #else
  254. _delay_ms(SHARED_MEM_SWITCH_DELAY);
  255. #endif
  256. avr_bus_active();
  257. snes_irq_lo();
  258. snes_irq_off();
  259. snes_lorom();
  260. snes_wr_disable();
  261. #if (DO_SHM_SCRATCHPAD==0)
  262. shared_memory_scratchpad_tx_restore();
  263. #endif
  264. #if SHARED_MEM_SWITCH_IRQ
  265. shared_memory_irq_restore();
  266. #endif
  267. sram_bulk_addr_restore();
  268. #endif
  269. }
  270. void shared_memory_yield()
  271. {
  272. snes_hirom();
  273. snes_wr_disable();
  274. snes_bus_active();
  275. _delay_ms(SHARED_MEM_SWITCH_DELAY);
  276. avr_bus_active();
  277. snes_lorom();
  278. snes_wr_disable();
  279. }
  280. int shared_memory_read(uint8_t * cmd, uint8_t * len, uint8_t * buffer)
  281. {
  282. // uint8_t state;
  283. #if DO_SHM
  284. #if DO_SHM_SCRATCHPAD
  285. if (scratchpad_locked_rx) {
  286. debug_P(DEBUG_SHM, PSTR("shared_memory_write: locked_tx\n"));
  287. return 1;
  288. }
  289. #endif
  290. sram_bulk_addr_save();
  291. state = sram_read(SHARED_MEM_RX_LOC_STATE);
  292. if (state != SHARED_MEM_RX_AVR_ACK) {
  293. sram_bulk_addr_restore();
  294. return 1;
  295. }
  296. *cmd = sram_read(SHARED_MEM_RX_LOC_CMD);
  297. *len = sram_read(SHARED_MEM_RX_LOC_LEN);
  298. debug_P(DEBUG_SHM,
  299. PSTR("shared_memory_read: 0x%04x=0x%02x 0x%04x=0x%02x \n"),
  300. SHARED_MEM_RX_LOC_CMD, *cmd, SHARED_MEM_RX_LOC_LEN, *len);
  301. sram_bulk_copy_into_buffer(SHARED_MEM_RX_LOC_PAYLOAD, buffer, *len);
  302. sram_write(SHARED_MEM_RX_LOC_STATE, SHARED_MEM_RX_AVR_RTS);
  303. snes_hirom();
  304. snes_wr_disable();
  305. snes_bus_active();
  306. #if SHARED_MEM_SWITCH_IRQ
  307. snes_irq_on();
  308. snes_irq_lo();
  309. _delay_us(20);
  310. snes_irq_hi();
  311. snes_irq_off();
  312. #else
  313. _delay_ms(SHARED_MEM_SWITCH_DELAY);
  314. #endif
  315. avr_bus_active();
  316. snes_lorom();
  317. snes_wr_disable();
  318. sram_bulk_addr_restore();
  319. #endif
  320. return 0;
  321. }