main.c 6.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213
  1. #include <avr/io.h>
  2. #include <avr/wdt.h>
  3. #include <avr/interrupt.h> /* for sei() */
  4. #include <util/delay.h> /* for _delay_ms() */
  5. #include <stdlib.h>
  6. #include <avr/pgmspace.h> /* required by usbdrv.h */
  7. #include "usbdrv.h"
  8. #include "oddebug.h" /* This is also an example for using debug
  9. * macros */
  10. #include "requests.h" /* The custom request numbers we use */
  11. #include "uart.h"
  12. #include "sram.h"
  13. #include "debug.h"
  14. #include "crc.h"
  15. #define REQ_IDLE 0
  16. #define REQ_UPLOAD 1
  17. #define RES_CRC 2
  18. #define BUFFER_SIZE 256
  19. extern FILE uart_stdout;
  20. uint8_t read_buffer[BUFFER_SIZE];
  21. uint32_t req_addr = 0;
  22. uint32_t req_size;
  23. uint8_t req_bank;
  24. uint32_t req_bank_size;
  25. uint8_t req_state = REQ_IDLE;
  26. uint8_t rx_remaining = 0;
  27. uint8_t tx_remaining = 0;
  28. uint16_t sync_errors = 0;
  29. uint8_t tx_buffer[32];
  30. uint8_t data_buffer[4];
  31. uint32_t addr;
  32. void crc_check_memory(uint32_t top_addr)
  33. {
  34. uint16_t crc = 0;
  35. uint32_t addr;
  36. req_bank = 0;
  37. for (addr = 0x000000; addr < top_addr; addr += BUFFER_SIZE) {
  38. sram_read_buffer(addr, read_buffer, BUFFER_SIZE);
  39. crc = do_crc_update(crc, read_buffer, BUFFER_SIZE);
  40. if (addr && addr % 32768 == 0) {
  41. printf("crc_check_memory: req_bank: 0x%x Addr: 0x%lx CRC: %x\n",
  42. req_bank, addr, crc);
  43. req_bank++;
  44. crc = 0;
  45. }
  46. }
  47. }
  48. void crc_check_memory_
  49. range(uint32_t start_addr, uint32_t size)
  50. {
  51. uint16_t crc = 0;
  52. uint32_t addr;
  53. req_bank = 0;
  54. for (addr = start_addr; addr < start_addr + size; addr += BUFFER_SIZE) {
  55. sram_read_buffer(addr, read_buffer, BUFFER_SIZE);
  56. crc = do_crc_update(crc, read_buffer, BUFFER_SIZE);
  57. }
  58. tx_buffer[0] = crc & 0xff;
  59. tx_buffer[1] = (crc >> 8) & 0xff;
  60. printf("crc_check_memory_range: Addr: 0x%lx CRC: %x\n", addr, crc);
  61. }
  62. usbMsgLen_t usbFunctionSetup(uchar data[8])
  63. {
  64. usbRequest_t *rq = (void *) data;
  65. uint8_t ret_len = 0;
  66. if (rq->bRequest == USB_UPLOAD_INIT) {
  67. req_bank = 0;
  68. rx_remaining = 0;
  69. req_bank_size = 1 << rq->wValue.word;
  70. sync_errors = 0;
  71. printf("USB_UPLOAD_INIT: bank size %li\n", req_bank_size);
  72. } else if (rq->bRequest == USB_UPLOAD_ADDR) { /* echo -- used for
  73. * reliability tests */
  74. req_state = REQ_UPLOAD;
  75. req_addr = rq->wValue.word;
  76. req_addr = req_addr << 16;
  77. req_addr = req_addr | rq->wIndex.word;
  78. if (rx_remaining) {
  79. sync_errors++;
  80. printf
  81. ("USB_UPLOAD_ADDR: Out of sync Addr=0x%lx remain=%i packet=%i sync_error=%i\n",
  82. req_addr, rx_remaining, rq->wLength.word, sync_errors);
  83. ret_len = 0;
  84. }
  85. rx_remaining = rq->wLength.word;
  86. ret_len = 0xff;
  87. if (req_addr && req_addr % req_bank_size == 0) {
  88. printf("USB_UPLOAD_ADDR: req_bank: 0x%x Addr: 0x%08lx \n",
  89. req_bank, req_addr);
  90. req_bank++;
  91. }
  92. ret_len = 0xff;
  93. } else if (rq->bRequest == USB_DOWNLOAD_INIT) {
  94. printf("USB_DOWNLOAD_INIT\n");
  95. } else if (rq->bRequest == USB_DOWNLOAD_ADDR) {
  96. printf("USB_DOWNLOAD_ADDR\n");
  97. } else if (rq->bRequest == USB_CRC) {
  98. req_addr = rq->wValue.word;
  99. req_addr = req_addr << 16;
  100. req_addr = req_addr | rq->wIndex.word;
  101. printf("USB_CRC: Addr 0x%lx \n", req_addr);
  102. cli();
  103. crc_check_memory(req_addr);
  104. sei();
  105. } else if (rq->bRequest == USB_CRC_ADDR) {
  106. req_addr = rq->wValue.word;
  107. req_addr = req_addr << 16;
  108. req_addr = req_addr | rq->wIndex.word;
  109. printf("USB_CRC_ADDR: Addr: 0x%lx Size: %i\n", req_addr,
  110. rq->wLength.word);
  111. req_size = rq->wLength.word;
  112. req_size = req_size << 2;
  113. tx_remaining = 2;
  114. printf("USB_CRC_ADDR: Addr: 0x%lx Size: %li\n", req_addr, req_size);
  115. cli();
  116. // crc_check_memory_range(req_addr,req_size);
  117. sei();
  118. ret_len = 2;
  119. }
  120. usbMsgPtr = data_buffer;
  121. return ret_len; /* default for not implemented requests: return
  122. * no data back to host */
  123. }
  124. uint8_t usbFunctionWrite(uint8_t * data, uint8_t len)
  125. {
  126. if (len > rx_remaining) {
  127. printf("usbFunctionWrite more data than expected remain: %i len: %i\n",
  128. rx_remaining, len);
  129. len = rx_remaining;
  130. }
  131. if (req_state == REQ_UPLOAD) {
  132. rx_remaining -= len;
  133. #if 1
  134. printf("usbFunctionWrite addr: 0x%08lx len: %i rx_remaining=%i\n",
  135. req_addr, len, rx_remaining);
  136. #endif
  137. cli();
  138. sram_copy(req_addr, data, len);
  139. sei();
  140. req_addr += len;
  141. }
  142. return len;
  143. }
  144. uint8_t usbFunctionRead(uint8_t * data, uint8_t len)
  145. {
  146. uint8_t i;
  147. if (len > tx_remaining)
  148. len = tx_remaining;
  149. tx_remaining -= len;
  150. #if 1
  151. printf("usbFunctionRead len=%i tx_remaining=%i \n", len, tx_remaining);
  152. #endif
  153. for (i = 0; i < len; i++) {
  154. *data = tx_buffer[len];
  155. data++;
  156. }
  157. return len;
  158. }
  159. /*
  160. * -------------------------------------------------------------------------
  161. */
  162. int main(void)
  163. {
  164. uint8_t i;
  165. wdt_enable(WDTO_1S);
  166. uart_init();
  167. stdout = &uart_stdout;
  168. sram_init();
  169. printf("SRAM Init\n");
  170. spi_init();
  171. printf("SPI Init\n");
  172. usbInit();
  173. printf("USB Init\n");
  174. usbDeviceDisconnect(); /* enforce re-enumeration, do this while
  175. * interrupts are disabled! */
  176. printf("USB disconnect\n");
  177. i = 10;
  178. while (--i) { /* fake USB disconnect for > 250 ms */
  179. wdt_reset();
  180. _delay_ms(1);
  181. }
  182. usbDeviceConnect();
  183. printf("USB connect\n");
  184. sei();
  185. printf("USB poll\n");
  186. for (;;) { /* main event loop */
  187. wdt_reset();
  188. usbPoll();
  189. }
  190. return 0;
  191. }
  192. /*
  193. * -------------------------------------------------------------------------
  194. */