sd_dma.v 3.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145
  1. `timescale 1ns / 1ps
  2. //////////////////////////////////////////////////////////////////////////////////
  3. // Company:
  4. // Engineer:
  5. //
  6. // Create Date: 19:19:08 12/01/2010
  7. // Design Name:
  8. // Module Name: sd_dma
  9. // Project Name:
  10. // Target Devices:
  11. // Tool versions:
  12. // Description:
  13. //
  14. // Dependencies:
  15. //
  16. // Revision:
  17. // Revision 0.01 - File Created
  18. // Additional Comments:
  19. //
  20. //////////////////////////////////////////////////////////////////////////////////
  21. module sd_dma(
  22. input [3:0] SD_DAT,
  23. inout SD_CLK,
  24. input CLK,
  25. input SD_DMA_EN,
  26. output SD_DMA_STATUS,
  27. output SD_DMA_SRAM_WE,
  28. output SD_DMA_NEXTADDR,
  29. output [7:0] SD_DMA_SRAM_DATA,
  30. input SD_DMA_PARTIAL,
  31. input [10:0] SD_DMA_PARTIAL_START,
  32. input [10:0] SD_DMA_PARTIAL_END,
  33. input SD_DMA_START_MID_BLOCK,
  34. input SD_DMA_END_MID_BLOCK,
  35. output [10:0] DBG_cyclecnt,
  36. output [2:0] DBG_clkcnt
  37. );
  38. reg [10:0] SD_DMA_STARTr;
  39. reg [10:0] SD_DMA_ENDr;
  40. reg SD_DMA_PARTIALr;
  41. always @(posedge CLK) SD_DMA_PARTIALr <= SD_DMA_PARTIAL;
  42. reg SD_DMA_DONEr;
  43. reg[1:0] SD_DMA_DONEr2;
  44. initial begin
  45. SD_DMA_DONEr2 = 2'b00;
  46. SD_DMA_DONEr = 1'b0;
  47. end
  48. always @(posedge CLK) SD_DMA_DONEr2 <= {SD_DMA_DONEr2[0], SD_DMA_DONEr};
  49. wire SD_DMA_DONE_rising = (SD_DMA_DONEr2[1:0] == 2'b01);
  50. reg [1:0] SD_DMA_ENr;
  51. initial SD_DMA_ENr = 2'b00;
  52. always @(posedge CLK) SD_DMA_ENr <= {SD_DMA_ENr[0], SD_DMA_EN};
  53. wire SD_DMA_EN_rising = (SD_DMA_ENr [1:0] == 2'b01);
  54. reg SD_DMA_STATUSr;
  55. assign SD_DMA_STATUS = SD_DMA_STATUSr;
  56. // we need 1042 cycles (startbit + 1024 nibbles + 16 crc + stopbit)
  57. reg [10:0] cyclecnt;
  58. initial cyclecnt = 11'd0;
  59. reg SD_DMA_SRAM_WEr;
  60. initial SD_DMA_SRAM_WEr = 1'b1;
  61. assign SD_DMA_SRAM_WE = (cyclecnt < 1025 && SD_DMA_STATUSr) ? SD_DMA_SRAM_WEr : 1'b1;
  62. reg SD_DMA_NEXTADDRr;
  63. assign SD_DMA_NEXTADDR = (cyclecnt < 1025 && SD_DMA_STATUSr) ? SD_DMA_NEXTADDRr : 1'b0;
  64. reg[7:0] SD_DMA_SRAM_DATAr;
  65. assign SD_DMA_SRAM_DATA = SD_DMA_SRAM_DATAr;
  66. // we have 4 internal cycles per SD clock, 8 per RAM byte write
  67. reg [2:0] clkcnt;
  68. initial clkcnt = 3'b000;
  69. reg [1:0] SD_CLKr;
  70. initial SD_CLKr = 3'b111;
  71. always @(posedge CLK)
  72. if(SD_DMA_EN_rising) SD_CLKr <= 3'b111;
  73. else SD_CLKr <= {SD_CLKr[0], clkcnt[1]};
  74. assign SD_CLK = SD_DMA_STATUSr ? SD_CLKr[1] : 1'bZ;
  75. always @(posedge CLK) begin
  76. if(SD_DMA_EN_rising) begin
  77. SD_DMA_STATUSr <= 1'b1;
  78. SD_DMA_STARTr <= (SD_DMA_PARTIALr ? SD_DMA_PARTIAL_START : 11'h0);
  79. SD_DMA_ENDr <= (SD_DMA_PARTIALr ? SD_DMA_PARTIAL_END : 11'd1024);
  80. end
  81. else if (SD_DMA_DONE_rising) SD_DMA_STATUSr <= 1'b0;
  82. end
  83. always @(posedge CLK) begin
  84. if(cyclecnt == 1042
  85. || ((SD_DMA_END_MID_BLOCK & SD_DMA_PARTIALr) && cyclecnt == SD_DMA_PARTIAL_END))
  86. SD_DMA_DONEr <= 1;
  87. else SD_DMA_DONEr <= 0;
  88. end
  89. always @(posedge CLK) begin
  90. if(SD_DMA_EN_rising || !SD_DMA_STATUSr) begin
  91. clkcnt <= 0;
  92. end else begin
  93. if(SD_DMA_STATUSr) begin
  94. clkcnt <= clkcnt + 1;
  95. end
  96. end
  97. end
  98. always @(posedge CLK) begin
  99. if(SD_DMA_EN_rising)
  100. cyclecnt <= (SD_DMA_PARTIALr && SD_DMA_START_MID_BLOCK) ? SD_DMA_PARTIAL_START : 0;
  101. else if(!SD_DMA_STATUSr) cyclecnt <= 0;
  102. else if(clkcnt[1:0] == 2'b10) cyclecnt <= cyclecnt + 1;
  103. end
  104. // we have 8 clk cycles to complete one RAM write
  105. // (4 clk cycles per SD_CLK; 2 SD_CLK cycles per byte)
  106. always @(posedge CLK) begin
  107. if(SD_DMA_STATUSr) begin
  108. case(clkcnt[2:0])
  109. 3'h0: begin
  110. SD_DMA_SRAM_DATAr[7:4] <= SD_DAT;
  111. if(cyclecnt>SD_DMA_STARTr && cyclecnt <= SD_DMA_ENDr) SD_DMA_NEXTADDRr <= 1'b1;
  112. end
  113. 3'h1: begin
  114. SD_DMA_NEXTADDRr <= 1'b0;
  115. end
  116. 3'h2: if(cyclecnt>=SD_DMA_STARTr && cyclecnt < SD_DMA_ENDr) SD_DMA_SRAM_WEr <= 1'b0;
  117. // 3'h3:
  118. 3'h4:
  119. SD_DMA_SRAM_DATAr[3:0] <= SD_DAT;
  120. // 3'h5:
  121. // 3'h6:
  122. 3'h7:
  123. SD_DMA_SRAM_WEr <= 1'b1;
  124. endcase
  125. end
  126. end
  127. endmodule