main.c 6.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212
  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_range(uint32_t start_addr, uint32_t size)
  49. {
  50. uint16_t crc = 0;
  51. uint32_t addr;
  52. req_bank = 0;
  53. for (addr = start_addr; addr < start_addr + size; addr += BUFFER_SIZE) {
  54. sram_read_buffer(addr, read_buffer, BUFFER_SIZE);
  55. crc = do_crc_update(crc, read_buffer, BUFFER_SIZE);
  56. }
  57. tx_buffer[0] = crc & 0xff;
  58. tx_buffer[1] = (crc >> 8) & 0xff;
  59. printf("crc_check_memory_range: Addr: 0x%lx CRC: %x\n", addr, crc);
  60. }
  61. usbMsgLen_t usbFunctionSetup(uchar data[8])
  62. {
  63. usbRequest_t *rq = (void *) data;
  64. uint8_t ret_len = 0;
  65. if (rq->bRequest == USB_UPLOAD_INIT) {
  66. req_bank = 0;
  67. rx_remaining = 0;
  68. req_bank_size = 1 << rq->wValue.word;
  69. sync_errors = 0;
  70. printf("USB_UPLOAD_INIT: bank size %li\n", req_bank_size);
  71. } else if (rq->bRequest == USB_UPLOAD_ADDR) { /* echo -- used for
  72. * reliability tests */
  73. req_state = REQ_UPLOAD;
  74. req_addr = rq->wValue.word;
  75. req_addr = req_addr << 16;
  76. req_addr = req_addr | rq->wIndex.word;
  77. if (rx_remaining) {
  78. sync_errors++;
  79. printf
  80. ("USB_UPLOAD_ADDR: Out of sync Addr=0x%lx remain=%i packet=%i sync_error=%i\n",
  81. req_addr, rx_remaining, rq->wLength.word, sync_errors);
  82. ret_len = 0;
  83. }
  84. rx_remaining = rq->wLength.word;
  85. ret_len = 0xff;
  86. if (req_addr && req_addr % req_bank_size == 0) {
  87. printf("USB_UPLOAD_ADDR: req_bank: 0x%x Addr: 0x%08lx \n",
  88. req_bank, req_addr);
  89. req_bank++;
  90. }
  91. ret_len = 0xff;
  92. } else if (rq->bRequest == USB_DOWNLOAD_INIT) {
  93. printf("USB_DOWNLOAD_INIT\n");
  94. } else if (rq->bRequest == USB_DOWNLOAD_ADDR) {
  95. printf("USB_DOWNLOAD_ADDR\n");
  96. } else if (rq->bRequest == USB_CRC) {
  97. req_addr = rq->wValue.word;
  98. req_addr = req_addr << 16;
  99. req_addr = req_addr | rq->wIndex.word;
  100. printf("USB_CRC: Addr 0x%lx \n", req_addr);
  101. cli();
  102. crc_check_memory(req_addr);
  103. sei();
  104. } else if (rq->bRequest == USB_CRC_ADDR) {
  105. req_addr = rq->wValue.word;
  106. req_addr = req_addr << 16;
  107. req_addr = req_addr | rq->wIndex.word;
  108. printf("USB_CRC_ADDR: Addr: 0x%lx Size: %i\n", req_addr,
  109. rq->wLength.word);
  110. req_size = rq->wLength.word;
  111. req_size = req_size << 2;
  112. tx_remaining = 2;
  113. printf("USB_CRC_ADDR: Addr: 0x%lx Size: %li\n", req_addr, req_size);
  114. cli();
  115. // crc_check_memory_range(req_addr,req_size);
  116. sei();
  117. ret_len = 2;
  118. }
  119. usbMsgPtr = data_buffer;
  120. return ret_len; /* default for not implemented requests: return
  121. * no data back to host */
  122. }
  123. uint8_t usbFunctionWrite(uint8_t * data, uint8_t len)
  124. {
  125. if (len > rx_remaining) {
  126. printf("usbFunctionWrite more data than expected remain: %i len: %i\n",
  127. rx_remaining, len);
  128. len = rx_remaining;
  129. }
  130. if (req_state == REQ_UPLOAD) {
  131. rx_remaining -= len;
  132. #if 1
  133. printf("usbFunctionWrite addr: 0x%08lx len: %i rx_remaining=%i\n",
  134. req_addr, len, rx_remaining);
  135. #endif
  136. cli();
  137. sram_copy(req_addr, data, len);
  138. sei();
  139. req_addr += len;
  140. }
  141. return len;
  142. }
  143. uint8_t usbFunctionRead(uint8_t * data, uint8_t len)
  144. {
  145. uint8_t i;
  146. if (len > tx_remaining)
  147. len = tx_remaining;
  148. tx_remaining -= len;
  149. #if 1
  150. printf("usbFunctionRead len=%i tx_remaining=%i \n", len, tx_remaining);
  151. #endif
  152. for (i = 0; i < len; i++) {
  153. *data = tx_buffer[len];
  154. data++;
  155. }
  156. return len;
  157. }
  158. /*
  159. * -------------------------------------------------------------------------
  160. */
  161. int main(void)
  162. {
  163. uint8_t i;
  164. //wdt_enable(WDTO_1S);
  165. uart_init();
  166. stdout = &uart_stdout;
  167. sram_init();
  168. printf("SRAM Init\n");
  169. spi_init();
  170. printf("SPI Init\n");
  171. usbInit();
  172. printf("USB Init\n");
  173. usbDeviceDisconnect(); /* enforce re-enumeration, do this while
  174. * interrupts are disabled! */
  175. printf("USB disconnect\n");
  176. i = 10;
  177. while (--i) { /* fake USB disconnect for > 250 ms */
  178. wdt_reset();
  179. _delay_ms(1);
  180. }
  181. usbDeviceConnect();
  182. printf("USB connect\n");
  183. sei();
  184. printf("USB poll\n");
  185. for (;;) { /* main event loop */
  186. wdt_reset();
  187. usbPoll();
  188. }
  189. return 0;
  190. }
  191. /*
  192. * -------------------------------------------------------------------------
  193. */