OpenCores
URL https://opencores.org/ocsvn/oms8051mini/oms8051mini/trunk

Subversion Repositories oms8051mini

[/] [oms8051mini/] [trunk/] [rtl/] [i2cm/] [i2cm_byte_ctrl.v] - Diff between revs 28 and 36

Show entire file | Details | Blame | View Log

Rev 28 Rev 36
Line 17... Line 17...
////      -Dinesh Annayya, dinesha@opencores.org                  ////
////      -Dinesh Annayya, dinesha@opencores.org                  ////
////                                                              ////
////                                                              ////
////  Revision : Jan 6, 2017                                      //// 
////  Revision : Jan 6, 2017                                      //// 
////                                                              ////
////                                                              ////
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
//     v0.0 - Dinesh A, 6th Jan 2017
////   v0.0 - Dinesh A, 6th Jan 2017
//          1. Initail version picked from
////        1. Initail version picked from
//              http://www.opencores.org/projects/i2c/
////            http://www.opencores.org/projects/i2c/
//          2. renaming of reset signal to aresetn and sresetn
////        2. renaming of reset signal to aresetn and sresetn
//
////   v0.1 - Dinesh.A, 19th Jan 2017
 
////        1. Lint Error fixes
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
////                                                              ////
////                                                              ////
//// Copyright (C) 2000 Authors and OPENCORES.ORG                 ////
//// Copyright (C) 2000 Authors and OPENCORES.ORG                 ////
////                                                              ////
////                                                              ////
//// This source file may be used and distributed without         ////
//// This source file may be used and distributed without         ////
Line 149... Line 150...
        assign dout = sr;
        assign dout = sr;
 
 
        // generate shift register
        // generate shift register
        always @(posedge clk or negedge aresetn)
        always @(posedge clk or negedge aresetn)
          if (!aresetn)
          if (!aresetn)
            sr <= #1 8'h0;
            sr <= 8'h0;
          else if (!sresetn)
          else if (!sresetn)
            sr <= #1 8'h0;
            sr <= 8'h0;
          else if (ld)
          else if (ld)
            sr <= #1 din;
            sr <= din;
          else if (shift)
          else if (shift)
            sr <= #1 {sr[6:0], core_rxd};
            sr <= {sr[6:0], core_rxd};
 
 
        // generate counter
        // generate counter
        always @(posedge clk or negedge aresetn)
        always @(posedge clk or negedge aresetn)
          if (!aresetn)
          if (!aresetn)
            dcnt <= #1 3'h0;
            dcnt <= 3'h0;
          else if (!sresetn)
          else if (!sresetn)
            dcnt <= #1 3'h0;
            dcnt <= 3'h0;
          else if (ld)
          else if (ld)
            dcnt <= #1 3'h7;
            dcnt <= 3'h7;
          else if (shift)
          else if (shift)
            dcnt <= #1 dcnt - 3'h1;
            dcnt <= dcnt - 3'h1;
 
 
        assign cnt_done = ~(|dcnt);
        assign cnt_done = ~(|dcnt);
 
 
        //
        //
        // state machine
        // state machine
Line 178... Line 179...
        reg [4:0] c_state; // synopsys enum_state
        reg [4:0] c_state; // synopsys enum_state
 
 
        always @(posedge clk or negedge aresetn)
        always @(posedge clk or negedge aresetn)
          if (!aresetn)
          if (!aresetn)
            begin
            begin
                core_cmd <= #1 `I2C_CMD_NOP;
                core_cmd <= `I2C_CMD_NOP;
                core_txd <= #1 1'b0;
                core_txd <= 1'b0;
                shift    <= #1 1'b0;
                shift    <= 1'b0;
                ld       <= #1 1'b0;
                ld       <= 1'b0;
                cmd_ack  <= #1 1'b0;
                cmd_ack  <= 1'b0;
                c_state  <= #1 ST_IDLE;
                c_state  <= ST_IDLE;
                ack_out  <= #1 1'b0;
                ack_out  <= 1'b0;
            end
            end
          else if (!sresetn | i2c_al)
          else if (!sresetn | i2c_al)
           begin
           begin
               core_cmd <= #1 `I2C_CMD_NOP;
               core_cmd <= `I2C_CMD_NOP;
               core_txd <= #1 1'b0;
               core_txd <= 1'b0;
               shift    <= #1 1'b0;
               shift    <= 1'b0;
               ld       <= #1 1'b0;
               ld       <= 1'b0;
               cmd_ack  <= #1 1'b0;
               cmd_ack  <= 1'b0;
               c_state  <= #1 ST_IDLE;
               c_state  <= ST_IDLE;
               ack_out  <= #1 1'b0;
               ack_out  <= 1'b0;
           end
           end
        else
        else
          begin
          begin
              // initially reset all signals
              // initially reset all signals
              core_txd <= #1 sr[7];
              core_txd <= sr[7];
              shift    <= #1 1'b0;
              shift    <= 1'b0;
              ld       <= #1 1'b0;
              ld       <= 1'b0;
              cmd_ack  <= #1 1'b0;
              cmd_ack  <= 1'b0;
 
 
              case (c_state) // synopsys full_case parallel_case
              case (c_state) // synopsys full_case parallel_case
                ST_IDLE:
                ST_IDLE:
                  if (go)
                  if (go)
                    begin
                    begin
                        if (start)
                        if (start)
                          begin
                          begin
                              c_state  <= #1 ST_START;
                              c_state  <= ST_START;
                              core_cmd <= #1 `I2C_CMD_START;
                              core_cmd <= `I2C_CMD_START;
                          end
                          end
                        else if (read)
                        else if (read)
                          begin
                          begin
                              c_state  <= #1 ST_READ;
                              c_state  <= ST_READ;
                              core_cmd <= #1 `I2C_CMD_READ;
                              core_cmd <= `I2C_CMD_READ;
                          end
                          end
                        else if (write)
                        else if (write)
                          begin
                          begin
                              c_state  <= #1 ST_WRITE;
                              c_state  <= ST_WRITE;
                              core_cmd <= #1 `I2C_CMD_WRITE;
                              core_cmd <= `I2C_CMD_WRITE;
                          end
                          end
                        else // stop
                        else // stop
                          begin
                          begin
                              c_state  <= #1 ST_STOP;
                              c_state  <= ST_STOP;
                              core_cmd <= #1 `I2C_CMD_STOP;
                              core_cmd <= `I2C_CMD_STOP;
                          end
                          end
 
 
                        ld <= #1 1'b1;
                        ld <= 1'b1;
                    end
                    end
 
 
                ST_START:
                ST_START:
                  if (core_ack)
                  if (core_ack)
                    begin
                    begin
                        if (read)
                        if (read)
                          begin
                          begin
                              c_state  <= #1 ST_READ;
                              c_state  <= ST_READ;
                              core_cmd <= #1 `I2C_CMD_READ;
                              core_cmd <= `I2C_CMD_READ;
                          end
                          end
                        else
                        else
                          begin
                          begin
                              c_state  <= #1 ST_WRITE;
                              c_state  <= ST_WRITE;
                              core_cmd <= #1 `I2C_CMD_WRITE;
                              core_cmd <= `I2C_CMD_WRITE;
                          end
                          end
 
 
                        ld <= #1 1'b1;
                        ld <= 1'b1;
                    end
                    end
 
 
                ST_WRITE:
                ST_WRITE:
                  if (core_ack)
                  if (core_ack)
                    if (cnt_done)
                    if (cnt_done)
                      begin
                      begin
                          c_state  <= #1 ST_ACK;
                          c_state  <= ST_ACK;
                          core_cmd <= #1 `I2C_CMD_READ;
                          core_cmd <= `I2C_CMD_READ;
                      end
                      end
                    else
                    else
                      begin
                      begin
                          c_state  <= #1 ST_WRITE;       // stay in same state
                          c_state  <= ST_WRITE;       // stay in same state
                          core_cmd <= #1 `I2C_CMD_WRITE; // write next bit
                          core_cmd <= `I2C_CMD_WRITE; // write next bit
                          shift    <= #1 1'b1;
                          shift    <= 1'b1;
                      end
                      end
 
 
                ST_READ:
                ST_READ:
                  if (core_ack)
                  if (core_ack)
                    begin
                    begin
                        if (cnt_done)
                        if (cnt_done)
                          begin
                          begin
                              c_state  <= #1 ST_ACK;
                              c_state  <= ST_ACK;
                              core_cmd <= #1 `I2C_CMD_WRITE;
                              core_cmd <= `I2C_CMD_WRITE;
                          end
                          end
                        else
                        else
                          begin
                          begin
                              c_state  <= #1 ST_READ;       // stay in same state
                              c_state  <= ST_READ;       // stay in same state
                              core_cmd <= #1 `I2C_CMD_READ; // read next bit
                              core_cmd <= `I2C_CMD_READ; // read next bit
                          end
                          end
 
 
                        shift    <= #1 1'b1;
                        shift    <= 1'b1;
                        core_txd <= #1 ack_in;
                        core_txd <= ack_in;
                    end
                    end
 
 
                ST_ACK:
                ST_ACK:
                  if (core_ack)
                  if (core_ack)
                    begin
                    begin
                       if (stop)
                       if (stop)
                         begin
                         begin
                             c_state  <= #1 ST_STOP;
                             c_state  <= ST_STOP;
                             core_cmd <= #1 `I2C_CMD_STOP;
                             core_cmd <= `I2C_CMD_STOP;
                         end
                         end
                       else
                       else
                         begin
                         begin
                             c_state  <= #1 ST_IDLE;
                             c_state  <= ST_IDLE;
                             core_cmd <= #1 `I2C_CMD_NOP;
                             core_cmd <= `I2C_CMD_NOP;
 
 
                             // generate command acknowledge signal
                             // generate command acknowledge signal
                             cmd_ack  <= #1 1'b1;
                             cmd_ack  <= 1'b1;
                         end
                         end
 
 
                         // assign ack_out output to bit_controller_rxd (contains last received bit)
                         // assign ack_out output to bit_controller_rxd (contains last received bit)
                         ack_out <= #1 core_rxd;
                         ack_out <=  core_rxd;
 
 
                         core_txd <= #1 1'b1;
                         core_txd <=  1'b1;
                     end
                     end
                   else
                   else
                     core_txd <= #1 ack_in;
                     core_txd <= ack_in;
 
 
                ST_STOP:
                ST_STOP:
                  if (core_ack)
                  if (core_ack)
                    begin
                    begin
                        c_state  <= #1 ST_IDLE;
                        c_state  <= ST_IDLE;
                        core_cmd <= #1 `I2C_CMD_NOP;
                        core_cmd <= `I2C_CMD_NOP;
 
 
                        // generate command acknowledge signal
                        // generate command acknowledge signal
                        cmd_ack  <= #1 1'b1;
                        cmd_ack  <= 1'b1;
                    end
                    end
 
               default: c_state  <= ST_IDLE;
 
 
              endcase
              endcase
          end
          end
endmodule
endmodule
 
 
 No newline at end of file
 No newline at end of file

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.