1. /*============================================================================
  2. *
  3. *  LOGIC CORE:          I2C控制器顶层文件
  4. *  MODULE NAME:         i2c_control()
  5. *  COMPANY:             武汉芯路恒科技有限公司
  6. *                       http://xiaomeige.taobao.com
  7. *  author:                                小梅哥
  8. *  Website:                                www.corecourse.cn
  9. *  REVISION HISTORY:  
  10. *
  11. *  Revision:                         1.0  04/10/2019     
  12. *  Description:                 Initial Release.
  13. *
  14. *  FUNCTIONAL DESCRIPTION:
  15. ===========================================================================*/
  16. module i2c_control(
  17.         Clk,
  18.         Rst_n,
  19.        
  20.         wrreg_req,
  21.         rdreg_req,
  22.         addr,
  23.         addr_mode,
  24.         wrdata,
  25.         rddata,
  26.         device_id,
  27.         RW_Done,
  28.        
  29.         ack,
  30.        
  31.         i2c_sclk,
  32.         i2c_sdat
  33. );
  34.         input Clk;
  35.         input Rst_n;
  36.        
  37.         input wrreg_req;
  38.         input rdreg_req;
  39.         input [15:0]addr;
  40.         input addr_mode;
  41.         input [7:0]wrdata;
  42.         output reg[7:0]rddata;
  43.         input [7:0]device_id;
  44.         output reg RW_Done;
  45.        
  46.         output reg ack;
  47.         output i2c_sclk;
  48.         inout i2c_sdat;
  49.        
  50.         reg [5:0]Cmd;
  51.         reg [7:0]Tx_DATA;
  52.         wire Trans_Done;
  53.         wire ack_o;
  54.         reg Go;
  55.         wire [15:0] reg_addr;
  56.        
  57.         assign reg_addr = addr_mode?addr:{addr[7:0],addr[15:8]};
  58.        
  59.         wire [7:0]Rx_DATA;
  60.        
  61.         localparam
  62.                 WR   = 6'b000001,   //写请求
  63.                 STA  = 6'b000010,   //起始位请求
  64.                 RD   = 6'b000100,   //读请求
  65.                 STO  = 6'b001000,   //停止位请求
  66.                 ACK  = 6'b010000,   //应答位请求
  67.                 NACK = 6'b100000;   //无应答请求
  68.        
  69.         i2c_bit_shift i2c_bit_shift(
  70.                 .Clk(Clk),
  71.                 .Rst_n(Rst_n),
  72.                 .Cmd(Cmd),
  73.                 .Go(Go),
  74.                 .Rx_DATA(Rx_DATA),
  75.                 .Tx_DATA(Tx_DATA),
  76.                 .Trans_Done(Trans_Done),
  77.                 .ack_o(ack_o),
  78.                 .i2c_sclk(i2c_sclk),
  79.                 .i2c_sdat(i2c_sdat)
  80.         );
  81.        
  82.         reg [6:0]state;
  83.         reg [7:0]cnt;
  84.        
  85.         localparam
  86.                 IDLE         = 7'b0000001,
  87.                 WR_REG       = 7'b0000010,
  88.                 WAIT_WR_DONE = 7'b0000100,
  89.                 WR_REG_DONE  = 7'b0001000,
  90.                 RD_REG       = 7'b0010000,
  91.                 WAIT_RD_DONE = 7'b0100000,
  92.                 RD_REG_DONE  = 7'b1000000;
  93.        
  94.         always@(posedge Clk or negedge Rst_n)
  95.         if(!Rst_n)begin
  96.                 Cmd <= 6'd0;
  97.                 Tx_DATA <= 8'd0;
  98.                 Go <= 1'b0;
  99.                 rddata <= 0;
  100.                 state <= IDLE;
  101.                 ack <= 0;
  102.         end
  103.         else begin
  104.                 case(state)
  105.                         IDLE:
  106.                                 begin
  107.                                         cnt <= 0;
  108.                                         ack <= 0;
  109.                                         RW_Done <= 1'b0;                                       
  110.                                         if(wrreg_req)
  111.                                                 state <= WR_REG;
  112.                                         else if(rdreg_req)
  113.                                                 state <= RD_REG;
  114.                                         else
  115.                                                 state <= IDLE;
  116.                                 end
  117.                        
  118.                         WR_REG:
  119.                                 begin
  120.                                         state <= WAIT_WR_DONE;
  121.                                         case(cnt)
  122.                                                 0:write_byte(WR | STA, device_id);
  123.                                                 1:write_byte(WR, reg_addr[15:8]);
  124.                                                 2:write_byte(WR, reg_addr[7:0]);
  125.                                                 3:write_byte(WR | STO, wrdata);
  126.                                                 default:;
  127.                                         endcase
  128.                                 end
  129.                        
  130.                         WAIT_WR_DONE:
  131.                                 begin
  132.                                         Go <= 1'b0;
  133.                                         if(Trans_Done)begin
  134.                                                 ack <= ack | ack_o;
  135.                                                 case(cnt)
  136.                                                         0: begin cnt <= 1; state <= WR_REG;end
  137.                                                         1:
  138.                                                                 begin
  139.                                                                         state <= WR_REG;
  140.                                                                         if(addr_mode)
  141.                                                                                 cnt <= 2;
  142.                                                                         else
  143.                                                                                 cnt <= 3;
  144.                                                                 end
  145.                                                                        
  146.                                                         2: begin
  147.                                                                         cnt <= 3;
  148.                                                                         state <= WR_REG;
  149.                                                                 end
  150.                                                         3:state <= WR_REG_DONE;
  151.                                                         default:state <= IDLE;
  152.                                                 endcase
  153.                                         end
  154.                                 end
  155.                        
  156.                         WR_REG_DONE:
  157.                                 begin
  158.                                         RW_Done <= 1'b1;
  159.                                         state <= IDLE;
  160.                                 end
  161.                                
  162.                         RD_REG:
  163.                                 begin
  164.                                         state <= WAIT_RD_DONE;
  165.                                         case(cnt)
  166.                                                 0:write_byte(WR | STA, device_id);
  167.                                                 1:if(addr_mode)
  168.                                                                 write_byte(WR, reg_addr[15:8]);
  169.                                                         else
  170.                                                                 write_byte(WR | STO, reg_addr[15:8]);
  171.                                                 2:write_byte(WR | STO, reg_addr[7:0]);
  172.                                                 3:write_byte(WR | STA, device_id | 8'd1);
  173.                                                 4:read_byte(RD | ACK | STO);
  174.                                                 default:;
  175.                                         endcase
  176.                                 end
  177.                                
  178.                         WAIT_RD_DONE:
  179.                                 begin
  180.                                         Go <= 1'b0;
  181.                                         if(Trans_Done)begin
  182.                                                 if(cnt <= 3)
  183.                                                         ack <= ack | ack_o;
  184.                                                 case(cnt)
  185.                                                         0: begin cnt <= 1; state <= RD_REG;end
  186.                                                         1:
  187.                                                                 begin
  188.                                                                         state <= RD_REG;
  189.                                                                         if(addr_mode)
  190.                                                                                 cnt <= 2;
  191.                                                                         else
  192.                                                                                 cnt <= 3;
  193.                                                                 end
  194.                                                                        
  195.                                                         2: begin
  196.                                                                         cnt <= 3;
  197.                                                                         state <= RD_REG;
  198.                                                                 end
  199.                                                         3:begin
  200.                                                                         cnt <= 4;
  201.                                                                         state <= RD_REG;
  202.                                                                 end
  203.                                                         4:state <= RD_REG_DONE;
  204.                                                         default:state <= IDLE;
  205.                                                 endcase
  206.                                         end
  207.                                 end
  208.                                
  209.                         RD_REG_DONE:
  210.                                 begin
  211.                                         RW_Done <= 1'b1;
  212.                                         rddata <= Rx_DATA;
  213.                                         state <= IDLE;                               
  214.                                 end
  215.                         default:state <= IDLE;
  216.                 endcase
  217.         end
  218.        
  219.         task read_byte;
  220.                 input [5:0]Ctrl_Cmd;
  221.                 begin
  222.                         Cmd <= Ctrl_Cmd;
  223.                         Go <= 1'b1;
  224.                 end
  225.         endtask
  226.        
  227.         task write_byte;
  228.                 input [5:0]Ctrl_Cmd;
  229.                 input [7:0]Wr_Byte_Data;
  230.                 begin
  231.                         Cmd <= Ctrl_Cmd;
  232.                         Tx_DATA <= Wr_Byte_Data;
  233.                         Go <= 1'b1;
  234.                 end
  235.         endtask
  236. endmodule