source: PlatformSupport/CustomPeripherals/pcores/eeprom_v1_07_a/hdl/verilog/onewiremaster.v

Last change on this file was 1166, checked in by murphpo, 15 years ago

adding updated EEPROM core/driver with better clocking
File size: 49.2 KB
Line 
1//--------------------------------------------------------------------------
2//                                                                        --
3//  OneWireMaster                                                         --
4//   A synthesizable 1-wire master peripheral                             --
5//   Copyright 1999-2005 Dallas Semiconductor Corporation                 --
6//                                                                        --
7//--------------------------------------------------------------------------
8//                                                                        --
9//  Purpose:  Provides timing and control of Dallas 1-wire bus            --
10//            through a memory-mapped peripheral                          --
11//  File:     OneWireMaster.v                                             --
12//  Date:     February 1, 2005                                            --
13//  Version:  v2.100                                                      --
14//  Authors:  Rick Downs and Charles Hill,                                --
15//            Dallas Semiconductor Corporation                            --
16//                                                                        --
17//  Note:     This source code is available for use without license.      --
18//            Dallas Semiconductor is not responsible for the             --
19//            functionality or utility of this product.                   --
20//                                                                        --
21//  REV:      Updated 1-Wire timings to match App Note 126 - SKH          --
22//            Added in Async MR of DQ_CONTROL - GAG                       --
23//            Changed WriteZero TimeSlotCnt to 60 instead of only 30 to   --
24//            match OneWire Spec. - GAG                                   --
25//            Added in bit control mode, left dqz for other function - GAG--
26//            Added strong pullup enable signal - GAG                     --
27//            Modified pd so it will not fire until the entire PD routine --
28//            has completed - GAG                                         --
29//            Added OW_LOW interrupt and OW_SHORT interrupt - GAG         --
30//            Added PPM and LLM for long line situations - GAG            --
31//            Changed logic for rsrf and rbf int flags - GAG              --
32//            Significant changes to improve synthesis - English          --
33//            Ported to Verilog - Sandelin                                --
34//--------------------------------------------------------------------------
35
36 module onewiremaster (
37   BIT_CTL, clk, clk_1us_en, clr_activate_intr, DQ_IN, EN_FOW, EOWL,
38   EOWSH, epd, erbf, ersf, etbe, etmt, FOW, ias, LLM, MR, OD,
39   owr, pd, PPM, rbf_reset, sr_a, STP_SPLY, STPEN, tbe, xmit_buffer,
40   clear_interrupts, DQ_CONTROL, FSM_CLK, INTR,
41   OneWireIO_eq_Load, OW_LOW, OW_SHORT, pdr, rbf, rcvr_buffer, reset_owr,
42   rsrf, STPZ, temt);
43
44   input       BIT_CTL;         // enable only single bit transmitions
45   input       clk;             //Master clk; much faster than 1us
46   input       clk_1us_en;         // 1us reference clock
47   input       clr_activate_intr;
48   input       DQ_IN;           // OW data input
49   input       EN_FOW;          // enable force OW functionality
50   input       EOWL;            // enable One wire bus low interrupt
51   input       EOWSH;           // enable One Wire bus short interrupt
52   input       epd;             // enable presence detect interrupt
53   input       erbf;            // enable receive buffer full interrupt
54   input       ersf;            // enable receive shift register full int.
55   input       etbe;            // enable transmit buffer empty interrupt
56   input       etmt;            // enable transmit shift inputister empty int.
57   input       FOW;             // Force OW value low
58   input       ias;             // INTR active state
59   input       LLM;             // long line mode enable
60   input       MR;              // master reset
61   input       OD;              // enable overdrive
62   input       owr;             // one wire reset ???
63   input       pd;              // presence detect interrupt
64   input       PPM;             // presence pulse masking enable
65   input       rbf_reset;       // clear for receive buffer full interrupt
66   input       sr_a;            // search rom accelorator enable
67   input       STP_SPLY;        // enable strong pull up supply mode
68   input       STPEN;           // enable strong pull up output
69   input       tbe;             // transmit buffer empty interrupt
70   input [7:0] xmit_buffer;     // transmit buffer
71
72
73   output       clear_interrupts;
74   output       DQ_CONTROL;     // OW pulldown control
75   output       FSM_CLK;        // state machine clk
76   output       INTR;           // One wire master interrupt output signal
77   output       OneWireIO_eq_Load;
78   output       OW_LOW;         // One wire low interrupt
79   output       OW_SHORT;       // One wire short interrupt
80   output       pdr;            // presence detect result
81   output       rbf;            // receive buffer full int
82   output [7:0] rcvr_buffer;    // receive register
83   output       reset_owr;      //
84   output       rsrf;           // receive shift reg full interrupt
85   output       STPZ;           // Strong pullup control (active low)
86   output       temt;           // transmit shift reg empty interrupt
87
88   //
89   // Define the states
90   //
91   parameter [2:0] Idle       = 3'b000,  // Idle
92                   CheckOWR   = 3'b001,  // Check for shorted OW
93                   Reset_Low  = 3'b010,  // Start reset
94                   PD_Wait    = 3'b011,  // release line for 1T
95                   PD_Sample  = 3'b100,  // sample line after slowest 1T over
96                   Reset_High = 3'b101,  // recover OW line level
97                   PD_Force   = 3'b110,  // mask the presence pulse
98                   PD_Release = 3'b111;  // recover OW line level
99
100  parameter [4:0] IdleS=      5'b00000, // Idle state
101                  Load=       5'b00001, // Load byte
102                  CheckOW=    5'b00010, // Check for shorted line
103                  DQLOW=      5'b00011, // Start of timeslot
104                  WriteZero=  5'b00100, // Write a zero to the 1-wire
105                  WriteOne=   5'b00101, // Write a one to the 1-wire
106                  ReadBit=    5'b00110, // Search Rom Accelerator read bit
107                  FirstPassSR=5'b00111, // Used by SRA
108                  WriteBitSR= 5'b01000, // Decide what bit value to write in SRA
109                  WriteBit=   5'b01001, // Writes the chosen bit in SRA
110                  WaitTS=     5'b01010, // Wait for end of time slot
111                  IndexInc=   5'b01011, // Increments bit index
112                  UpdateBuff= 5'b01100, // Updates states of rbf
113                  ODWriteZero=5'b01101, // Write a zero @ OD speed to OW
114                  ODWriteOne= 5'b01110, // Write a one @ OD speed to OW
115                  ClrLowDone= 5'b01111; // disable stpupz before pulldown
116
117
118   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
119   // micro-second count for bit transitions and sample
120   parameter [6:0]                      // Standard speed
121      bit_ts_writeone_high    = 7'b0000110, // release-1  @6 us
122      bit_ts_writeone_high_ll = 7'b0001000, // rel-1-LLM  @8 us
123      bit_ts_sample           = 7'b0001111, // sample     @15 us
124      bit_ts_sample_ll        = 7'b0011000, // sample/llm @24 us
125      bit_ts_writezero_high   = 7'b0111100, // release-0  @60 us
126      bit_ts_end              = 7'b1000110, // end        @70 us
127      bit_ts_end_ll           = 7'b1010000, // end        @80 us
128   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
129                                        // Overdrive speed
130      // note that due to the state machine architecture, the
131      // writeone_high_od and sample_od must be 1 and 2 us.
132      // writezero_high_od and end_od are adjustable, so long
133      // as writezero_high_od does not exceed a particular
134      // 1-Wire device max low time.
135      bit_ts_writeone_high_od  = 7'b0000001, // release-1 @1 us
136      bit_ts_sample_od         = 7'b0000010, // sample    @2 us
137      bit_ts_writezero_high_od = 7'b0001000, // release-0 @8 us
138      bit_ts_end_od            = 7'b0001001; // end       @10 us
139   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
140   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
141   // micro-second count for reset transitions
142   parameter [10:0]                     // Standard speed
143      reset_ts_release = 11'b01001011000,    // release @600 us
144      reset_ts_no_stpz = 11'b01001100010,    // stpz=1  @610 us
145      reset_ts_ppm     = 11'b01001101100,    // pp-mask @620 us
146      reset_ts_sample  = 11'b01010011110,    // sample  @670 us
147      reset_ts_llsample= 11'b01010101101,    // sample  @685 us
148      reset_ts_ppm_end = 11'b01010110010,    // ppm-end @690 us
149      reset_ts_stpz    = 11'b01110110110,    // stpz    @950 us
150      reset_ts_recover = 11'b01111000000,    // recover @960 us
151      reset_ts_end     = 11'b10000111000,    // end     @1080 us
152                                        // Overdrive speed
153      reset_ts_release_od = 11'b00001000110, // release @70 us
154      reset_ts_no_stpz_od = 11'b00001001011, // stpz=1  @75 us
155      reset_ts_sample_od  = 11'b00001001111, // sample  @79 us
156      reset_ts_stpz_od    = 11'b00001101001, // stpz    @105 us
157      reset_ts_recover_od = 11'b00001110011, // recover @115 us
158      reset_ts_end_od     = 11'b00010000000; // end     @128 us
159   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
160
161
162   wire            owr;         // 1W reset command
163   wire            sr_a;        // search ROM accelerator command
164
165   // interrupt register
166   wire            pd;          // presence detect done flag
167   reg             pdr;         // presence detect result
168   wire            tbe;         // transmit buffer empty flag
169   reg             temt;        // transmit shift register empty flag
170   wire            temt_ext;    // temt extended flag
171   reg             rbf;         // receive buffer full flag
172   reg             rsrf;        // receive shift register full flag
173   reg             OW_SHORT;    // OW line shorted interrupt
174   reg             OW_LOW;      // OW line low interrupt
175   reg             INTR;
176
177   //wire            rsrf_reset;  // clear signal for rsrf
178   reg             set_rbf;     // set signal for rbf
179
180   // interrupt enable register
181   wire            epd;         // enable presence detect interrupt
182   wire            ias;         // INTR active state
183   wire            etbe;        // enable transmit buffer empty interrupt
184   wire            etmt;        // enable transmit shift register empty int.
185   wire            erbf;        // enable receive buffer full interrupt
186   wire            ersf;        // enable receive shift register full int.
187   wire            EOWSH;       // enable ow shorted interrupt
188   wire            EOWL;        // enable ow low interrupt
189
190   wire            clr_activate_intr;
191   reg             reset_owr;
192
193   reg             activate_intr;
194   reg             dly_clr_activate_intr;
195   reg             clear_interrupts;
196
197   reg             SET_RSHRT;      // set ow_short prior to ow reset
198   reg             SET_IOSHRT;     // set ow_short prior to tx a bit
199
200   wire [7:0]      xmit_buffer;    // transmit buffer
201   reg [7:0]       xmit_shiftreg;  // transmit shift register
202
203   reg [7:0]       rcvr_buffer;    // receive buffer
204   reg [7:0]       rcvr_shiftreg;  // receive shift register
205
206   reg             last_rcvr_bit;  // active on index = 7 to begin shift to rbe
207   reg             byte_done;
208   reg             byte_done_flag, bdext1;  // signals to stretch byte_done
209
210   reg             First;          // for Search ROM accelerator
211   reg             BitRead1;
212   reg             BitRead2;
213   reg             BitWrite;
214
215   reg [2:0]       OneWireReset;
216   reg [4:0]       OneWireIO;
217
218   reg [10:0]      count;
219   //reg [4:0]       smCnt;
220   reg [3:0]       index;
221   reg [6:0]       TimeSlotCnt;
222
223   reg             PD_READ;
224   reg             LOW_DONE;
225   reg             DQ_CONTROL_F;
226   wire            DQ_CONTROL;
227   wire            STPZ;
228   reg             DQ_IN_HIGH;
229   reg             OD_DQH;
230    reg             rbf_set;
231    reg             rsrf_reset;
232
233   reg             ROW;
234
235//   wire FSM_CLK = clk_1us;
236   wire FSM_CLK = clk;
237
238   //
239   //  1 wire control
240   //
241   assign DQ_CONTROL = MR ? 1'b1 : DQ_CONTROL_F;  //GAG added in asynch RESET
242
243   always @(posedge clk)                      //GAG added in ODWriteZero
244    begin
245        if(clk_1us_en)
246        begin
247          DQ_CONTROL_F <=
248                       (EN_FOW == 1) && (FOW == 1)?0:
249                       OneWireReset == Reset_Low?0:
250                       OneWireReset == PD_Wait?1:
251                       OneWireReset == PD_Force?0:
252                       OneWireIO == DQLOW?0:
253                       OneWireIO == WriteZero?0:
254                       OneWireIO == ODWriteZero?0:
255                       OneWireIO == WriteBit?0:
256                       1;
257        end
258    end
259
260   wire OneWireIO_eq_Load = OneWireIO == Load;
261
262   //
263   // Strong Pullup control section - GAG
264   // not pulling line low, not checking for pres detect, and
265   // OW has recovered from read
266   // SPLY is only for enabling STP when a slave requires high current
267   //   and STP_SPLY is enabled
268   //
269   wire   SPLY = (STP_SPLY && (OneWireReset == Idle) && (OneWireIO == IdleS));
270   assign STPZ = !(STPEN && DQ_CONTROL && DQ_IN_HIGH
271                   && (PD_READ || LOW_DONE || SPLY));
272
273   always @(posedge MR or posedge FSM_CLK)
274    begin
275     if (MR)
276       begin
277         DQ_IN_HIGH <= 0;
278         OD_DQH <=0;
279       end
280        else if(clk_1us_en)
281        begin
282         if (OD)
283           if(DQ_IN && !DQ_IN_HIGH && !OD_DQH)
284             begin
285               DQ_IN_HIGH <= 1;
286               OD_DQH <=1;
287             end
288           else if(OD_DQH && DQ_IN)
289             DQ_IN_HIGH <= 0;
290           else
291             begin
292               OD_DQH <=0;
293               DQ_IN_HIGH <= 0;
294             end
295         else
296           begin
297             if(DQ_IN && !DQ_IN_HIGH)
298               DQ_IN_HIGH <= 1;
299             else if (DQ_IN && DQ_IN_HIGH)
300               DQ_IN_HIGH <= DQ_IN_HIGH;
301             else
302               DQ_IN_HIGH <= 0;
303           end
304      end
305    end
306
307   //
308   // Update receive buffer and the rsrf and rbf int flags
309   //
310    always @(posedge MR or posedge rbf_reset or posedge rbf_set)
311     if (MR)
312      rbf <= 0;
313     else if (rbf_reset)  //note that rbf resets at the beginning of the RX buff read
314      rbf <= 0;
315     else
316      rbf <= 1;
317
318   always @(posedge MR or posedge FSM_CLK)
319     if (MR)
320       rsrf <= 1'b0;
321    else if(clk_1us_en)
322    begin
323         if (last_rcvr_bit || BIT_CTL)
324           begin
325             if (OneWireIO == IndexInc)
326               rsrf <= 1'b1;
327             else if (rsrf_reset)
328               rsrf <= 1'b0;
329           end
330         else if (rsrf_reset || (OneWireIO == DQLOW))
331           rsrf <= 1'b0;
332    end
333   
334   always @(posedge FSM_CLK or posedge MR)
335     if (MR)
336       begin
337         rcvr_buffer <= 0;
338         rbf_set <= 0;
339       end
340     else if(clk_1us_en)
341       if (rsrf && !rbf)
342         begin
343           rcvr_buffer <= rcvr_shiftreg;
344           rbf_set <= 1'b1;
345           rsrf_reset <= 1'b1;
346         end
347       else
348         begin
349           rbf_set <= 1'b0;
350           if (!rsrf)
351             rsrf_reset <= 1'b0;
352         end
353
354   //
355   // Update OW shorted interrupt
356   //
357   always @(posedge MR or posedge FSM_CLK)
358     begin
359       if(MR)
360         OW_SHORT <= 1'b0;
361       else if(clk_1us_en)
362       begin
363           if (SET_RSHRT || SET_IOSHRT)
364             OW_SHORT <= 1'b1;
365           else if (clr_activate_intr)
366             OW_SHORT <= 1'b0;
367           else
368             OW_SHORT <= OW_SHORT;
369         end
370      end
371   //
372   // Update OW bus low interrupt
373   //
374   always @(posedge MR or posedge FSM_CLK)
375     begin
376       if (MR)
377         OW_LOW <= 0;
378       else if(clk_1us_en)
379       begin
380           if (!DQ_IN && (OneWireReset == Idle) && (OneWireIO == IdleS))
381             OW_LOW <= 1;
382           else if (clr_activate_intr)
383             OW_LOW <= 0;
384           else
385             OW_LOW <= OW_LOW;
386       end
387     end
388
389   ///////////////////////////////////////////////////////////////
390   // The following section handles the interrupt itself
391   ///////////////////////////////////////////////////////////////
392
393   //
394   // Create clear interrupts
395   //
396   always @(posedge MR or posedge FSM_CLK)
397      if (MR)
398         begin
399            //dly_clr_activate_intr <= 1'b0;
400            clear_interrupts <= 1'b0;
401         end // if (MR)
402      else if(clk_1us_en)
403         begin
404            //dly_clr_activate_intr<=clr_activate_intr;
405            clear_interrupts<=clr_activate_intr;
406            //clear_interrupts <= dly_clr_activate_intr ;
407         end
408
409   wire acint_reset = MR || clr_activate_intr;
410
411   //
412   // Check for active interrupt
413   //
414   always @(posedge acint_reset or posedge FSM_CLK)
415     if(acint_reset)
416        activate_intr <= 1'b0;
417      else if(clk_1us_en)
418        case(1)
419          pd && epd:
420             activate_intr <= 1'b1;
421          tbe && etbe && !temt:
422             activate_intr <= 1'b1;
423          temt_ext && etmt:
424             activate_intr <= 1'b1;
425          rbf && erbf:
426             activate_intr <= 1'b1;
427          rsrf && ersf:
428             activate_intr <= 1'b1;
429          OW_LOW && EOWL:
430             activate_intr <= 1'b1;
431          OW_SHORT && EOWSH:
432             activate_intr <= 1'b1;
433        endcase // case(1)
434
435   //
436   // Create INTR signal by checking for active interrupt and active
437   // state of INTR
438   //
439   always @(activate_intr or ias)
440      case({activate_intr,ias})
441        2'b11:
442           INTR <= 1'b1;
443        2'b01:
444           INTR <= 1'b0;
445        2'b10:
446           INTR <= 1'b1; // shughes - 8-16-04 - was 1'b0
447        default:
448           INTR <= 1'b0; // shughes - 8-16-04 - was 1'b1
449      endcase // case({activate_intr,ias})
450
451
452
453   //--------------------------------------------------------------------------
454   //
455   //  OneWireReset
456   //
457   //  this state machine performs the 1-wire reset and presence detect
458   //  - Added OD for overdrive speed presence detect
459   //  - Added PD_LOW bit for strong pullup control
460   //
461   //  Idle       : OW high - waiting to issue a PD
462   //  CheckOWR   : OW high - checks for shorted OW line
463   //  Reset_Low  : OW low - held down for GT8 OW osc periods
464   //  PD_Wait    : OW high - released and waits for 1T
465   //  PD_Sample  : OW high - checks to see if a slave is out there pulling
466   //                         OW low for 4T
467   //  Reset_High : OW high - slave, if any, release OW and host lets it recover
468   //--------------------------------------------------------------------------
469
470   always @(posedge FSM_CLK or posedge MR)
471      if(MR) begin
472         pdr <= 1'b1;        // Added default state to conform to spec - SDS
473         OneWireReset <= Idle;
474         //smCnt <= 0;         // added to init simulations
475         count <= 0;
476         PD_READ <= 0;       // Added PD_READ - GAG
477         reset_owr <= 0;
478         SET_RSHRT <= 0;     //
479            ROW <= 0;
480      end
481      else if(clk_1us_en)
482      begin
483       if(!owr)
484       begin
485         count <= 0;
486            ROW <= 0;
487         reset_owr <= 0;
488         OneWireReset <= Idle;
489       end
490           else
491              case(OneWireReset)
492                Idle: begin
493                   if (ROW)
494                          reset_owr <= 1;
495                      else
496                           begin
497                              count <= 0;
498                       SET_RSHRT <=0;
499                       reset_owr <= 0;
500                       OneWireReset <= CheckOWR;
501                     end
502                      end
503
504                CheckOWR: begin
505                   OneWireReset <= Reset_Low;
506                   if(!DQ_IN)
507                     SET_RSHRT <= 1;
508                   end
509
510                Reset_Low: begin
511                   count <= count + 1;
512                   PD_READ <= 0;                // Added PD_READ - GAG
513                   if(OD)                       // Added OD - GAG
514                     begin
515                       // tRSTL - OD
516                       if(count == reset_ts_release_od)
517                         begin
518                           OneWireReset <= PD_Wait;
519                           PD_READ <= 1;
520                         end
521                     end
522                   // tRSTL - STD
523                   else if(count == reset_ts_release)
524                     begin
525                       OneWireReset <= PD_Wait;
526                       PD_READ <= 1;
527                     end
528                end
529
530                PD_Wait: begin
531                   SET_RSHRT <= 0;
532                   count <= count + 1;
533                   if(!DQ_IN & DQ_CONTROL_F) begin
534                      OneWireReset <= PD_Sample;
535                      //smCnt <= 0;
536                   end
537                   else if(OD)
538                     begin
539                       // (tRSTL + pull-up time) - OD
540                       if(count==reset_ts_no_stpz_od)
541                         // disables stp_sply
542                         PD_READ <= 0;       // Be sure to turn off 4 MPD mode
543                       // tMSP - OD
544                       else if(count == reset_ts_sample_od)
545                         begin
546                           OneWireReset <= PD_Sample;
547                           //smCnt <= 0;
548                         end
549                     end
550                   // (tRSTL + pull-up time) - STD
551                   else if(count == reset_ts_no_stpz)
552                     // disables stp_sply
553                     PD_READ <= 0; // Be sure to turn off 4 MPD mode
554                   // tPPM1 - STD
555                   else if((count == reset_ts_ppm) && PPM)
556                     OneWireReset <= PD_Force;
557                   // tMSP - STD
558                   else if(count == reset_ts_llsample && !LLM)
559                     begin
560                       OneWireReset <= PD_Sample;
561                       //smCnt <= 0;
562                     end
563                   else if(count == reset_ts_sample && LLM)
564                     begin
565                       OneWireReset <= PD_Sample;
566                       //smCnt <= 0;
567                     end
568                end
569
570                PD_Sample: begin
571                   PD_READ <= 0;
572                   count <= count + 1;
573                   //smCnt <= smCnt + 1;
574                   //if (OD)                      // Added OD - GAG
575                   //  begin
576                   //    if(smCnt == 3-1)
577                   //      begin
578                           pdr <= DQ_IN;
579                           OneWireReset <= Reset_High;
580                   //      end
581                   //  end
582                   //else
583                   //  if(smCnt == 30-1)
584                   //    begin
585                   //      pdr <= DQ_IN;
586                   //      OneWireReset <= Reset_High;
587                   //    end
588                end
589
590                Reset_High: begin
591                   count <= count + 1;
592                   if (OD)                      // Added OD - GAG
593                     begin
594                       if (count == reset_ts_stpz_od)
595                         begin
596                           if (DQ_IN)
597                              PD_READ <= 1;
598                         end
599                       else if (count == reset_ts_recover_od)
600                         begin
601                           PD_READ <= 0;
602                         end
603                       else if (count == reset_ts_end_od)
604                         begin
605                           PD_READ <= 0;
606                           OneWireReset <= Idle;
607                           ROW <= 1;
608                         end
609                     end
610                   else
611                     begin
612                       if(count == reset_ts_stpz)
613                         begin
614                           if (DQ_IN)
615                             PD_READ <= 1;
616                         end
617                       else if (count == reset_ts_recover)
618                         begin
619                           PD_READ <= 0;
620                         end
621                       else if (count == reset_ts_end)
622                         begin
623                           PD_READ <= 0;
624                           OneWireReset <= Idle;
625                           ROW <= 1;
626                         end
627                     end
628                end
629
630                PD_Force:  begin
631                  count <= count + 1;
632                  // tPPM2
633                  if (count == reset_ts_ppm_end)
634                    begin
635                      OneWireReset <= PD_Release;
636                    end
637                end
638
639                PD_Release: begin
640                  count <= count + 1;
641                  pdr <= 0;              //force valid result
642                  if(count == reset_ts_stpz)
643                    begin
644                      if (DQ_IN)
645                        PD_READ <= 1;
646                    end
647                  else if (count == reset_ts_recover)
648                    begin
649                      PD_READ <= 0;
650                    end
651                  else if (count == reset_ts_end)
652                    begin
653                      PD_READ <= 0;
654                      OneWireReset <= Idle;
655                      ROW <= 1;
656                    end
657                end
658
659              endcase
660    end
661
662   //--------------------------------------------------------------------------
663   //
664   //  OneWireIO
665   //
666   //  this state machine performs the 1-wire writing and reading
667   //  - Added ODWriteZero and ODWriteOne for overdrive timing
668   //
669   //  IdleS       : Waiting for transmit byte to be loaded
670   //  ClrLowDone  : Disables strong pullup before pulldown turns on
671   //  Load        : Loads byte to shift reg
672   //  CheckOW     : Checks for OW short
673   //  DQLOW       : Starts time slot with OW = 0
674   //  ODWriteZero : Completes write of 0 bit / read bit in OD speed
675   //  ODWriteOne  : Completes write of 1 bit / read bit in OD speed
676   //  WriteZero   : Completes write of 0 bit / read bit in standard speed
677   //  WriteOne    : Completes write of 1 bit / read bit in standard speed
678   //  ReadBit     : AutoSearchRom : Reads the first bit value
679   //  FirstPassSR : AutoSearchRom : Decides to do another read or the write
680   //  WriteBitSR  : AutoSearchRom : Determines the bit to write
681   //  WriteBit    : AutoSearchRom : Writes the bit
682   //  WatiTS      : Allows OW to recover for the remainder of the time slot
683   //  IndexInc    : Increment the index to send out next bit (in byte)
684   //  UpdateBuff  : Allows other signals to update following finished byte/bit
685   //--------------------------------------------------------------------------
686
687   // The following 2 registers are to stretch the temt signal to catch the
688   // temt interrupt source - SDS
689
690   always @(posedge MR or posedge FSM_CLK)
691      if(MR)
692         bdext1 <= 1'b0;
693      else if(clk_1us_en)
694         bdext1 <= byte_done;
695
696   always @(posedge MR or posedge FSM_CLK)
697      if(MR)
698         byte_done_flag <= 1'b0;
699      else if(clk_1us_en)
700         byte_done_flag <= bdext1;
701
702   assign temt_ext = temt && byte_done_flag;
703
704   // The index variable has been decoded explicitly in this state machine
705   // so that the code would compile on the Cypress warp compiler - SDS
706   always @(posedge FSM_CLK or posedge MR)
707      if(MR) begin
708         index <= 0;
709         TimeSlotCnt <= 0;
710         temt <= 1'b1;
711         last_rcvr_bit <= 1'b0;
712         rcvr_shiftreg <= 0;
713         OneWireIO <= IdleS;
714         BitRead1<=0;
715         BitRead2<=0;
716         BitWrite<=0;
717         First <= 1'b0;
718         byte_done <= 1'b0;
719         xmit_shiftreg<=0;
720         LOW_DONE <= 0;
721         SET_IOSHRT <= 0;
722      end
723      else if(clk_1us_en)
724         case(OneWireIO)
725
726           // IdleS state clears variables and waits for something to be
727           // deposited in the transmit buffer. When something is there,
728           // the next state is Load.
729           IdleS:
730              begin
731                 byte_done <= 1'b0;
732                 index <= 0;
733                 last_rcvr_bit <= 1'b0;
734                 First <= 1'b0;
735                 TimeSlotCnt <= 0;
736                 LOW_DONE <= 0;
737                 SET_IOSHRT <= 0;
738                 temt <= 1'b1;
739                 if(!tbe)
740                   begin
741                     if(STPEN)
742                       OneWireIO <= ClrLowDone;
743                     else
744                       OneWireIO <= Load;
745                   end
746                 else
747                    OneWireIO <= IdleS;
748              end
749
750           // New state added to be sure the strong pullup will be disabled
751           // before the OW pulldown turns on
752           ClrLowDone:
753              begin
754                 LOW_DONE <= 0;
755                 if (!LOW_DONE)
756                   OneWireIO <= Load;
757              end
758
759           // Load transfers the transmit buffer to the transmit shift register,
760           // then clears the transmit shift register empty interrupt. The next
761           // state is then DQLOW.
762           Load:
763              begin
764                 xmit_shiftreg <= xmit_buffer;
765                 rcvr_shiftreg <= 0;
766                 temt <= 1'b0;
767                 LOW_DONE <= 0;
768                 OneWireIO <= CheckOW;
769              end
770
771           // Checks OW value before sending out every bit to see if line
772           // was forced low by some other means at an incorrect time
773           CheckOW:
774             begin
775               OneWireIO <= DQLOW;
776               //TimeSlotCnt <= TimeSlotCnt + 1;
777               if (!DQ_IN)
778                 SET_IOSHRT <= 1;
779             end
780
781           // DQLOW pulls the DQ line low for 1us, beginning a timeslot.
782           // If sr_a is 0, it is a normal write/read operation. If sr_a
783           // is a 1, then you must go into Search ROM accelerator mode.
784           // If OD is 1, the part is in overdrive and must perform
785           // ODWrites instead of normal Writes while OD is 0.
786           DQLOW:
787             begin
788              TimeSlotCnt <= TimeSlotCnt + 1;
789              LOW_DONE <= 0;
790              if (OD)
791               begin
792                  //if(TimeSlotCnt==bit_ts_writeone_high_od)
793                  //begin
794                   if(!sr_a)
795                     begin
796                       case(index)
797                         0:
798                            if(!xmit_shiftreg[0])
799                               OneWireIO <= ODWriteZero;
800                            else
801                               OneWireIO <= ODWriteOne;
802                         1:
803                            if(!xmit_shiftreg[1])
804                               OneWireIO <= ODWriteZero;
805                            else
806                               OneWireIO <= ODWriteOne;
807                         2:
808                            if(!xmit_shiftreg[2])
809                               OneWireIO <= ODWriteZero;
810                            else
811                               OneWireIO <= ODWriteOne;
812                         3:
813                            if(!xmit_shiftreg[3])
814                               OneWireIO <= ODWriteZero;
815                            else
816                               OneWireIO <= ODWriteOne;
817                         4:
818                            if(!xmit_shiftreg[4])
819                               OneWireIO <= ODWriteZero;
820                            else
821                               OneWireIO <= ODWriteOne;
822                         5:
823                            if(!xmit_shiftreg[5])
824                               OneWireIO <= ODWriteZero;
825                            else
826                               OneWireIO <= ODWriteOne;
827                         6:
828                            if(!xmit_shiftreg[6])
829                               OneWireIO <= ODWriteZero;
830                            else
831                               OneWireIO <= ODWriteOne;
832                         7:
833                            if(!xmit_shiftreg[7])
834                               OneWireIO <= ODWriteZero;
835                            else
836                               OneWireIO <= ODWriteOne;
837                       endcase // case(index)
838                     end
839                   else         // Search Rom Accelerator mode
840                     OneWireIO <= ReadBit;
841                  end
842               //end
843              else if(((TimeSlotCnt==bit_ts_writeone_high) && !LLM) || 
844                      ((TimeSlotCnt==bit_ts_writeone_high_ll) && LLM))
845              begin
846                 if(!sr_a)                  // Normal write
847                   begin
848                      case(index)
849                        0:
850                           if(!xmit_shiftreg[0])
851                              OneWireIO <= WriteZero;
852                           else
853                              OneWireIO <= WriteOne;
854                        1:
855                           if(!xmit_shiftreg[1])
856                              OneWireIO <= WriteZero;
857                           else
858                              OneWireIO <= WriteOne;
859                        2:
860                           if(!xmit_shiftreg[2])
861                              OneWireIO <= WriteZero;
862                           else
863                              OneWireIO <= WriteOne;
864                        3:
865                           if(!xmit_shiftreg[3])
866                              OneWireIO <= WriteZero;
867                           else
868                              OneWireIO <= WriteOne;
869                        4:
870                           if(!xmit_shiftreg[4])
871                              OneWireIO <= WriteZero;
872                           else
873                              OneWireIO <= WriteOne;
874                        5:
875                           if(!xmit_shiftreg[5])
876                              OneWireIO <= WriteZero;
877                           else
878                              OneWireIO <= WriteOne;
879                        6:
880                           if(!xmit_shiftreg[6])
881                              OneWireIO <= WriteZero;
882                           else
883                              OneWireIO <= WriteOne;
884                        7:
885                           if(!xmit_shiftreg[7])
886                              OneWireIO <= WriteZero;
887                           else
888                              OneWireIO <= WriteOne;
889                      endcase // case(index)
890                  end
891                  else         // Search Rom Accelerator mode
892                     OneWireIO <= ReadBit;
893                  end
894               end
895
896           // WriteZero and WriteOne are identical, except for what they do to
897           // DQ (assigned in concurrent assignments). They both read DQ after
898           // 15us, then move on to wait for the end of the timeslot, unless
899           // running in Long Line mode which extends the sample time out to 22
900           WriteZero:
901             begin
902              TimeSlotCnt <= TimeSlotCnt + 1;
903              if(((TimeSlotCnt==bit_ts_sample) && !sr_a && !LLM) ||
904                 ((TimeSlotCnt==bit_ts_sample_ll) && !sr_a &&  LLM))
905                 case(index)
906                   0:
907                      rcvr_shiftreg[0] <= DQ_IN;
908                   1:
909                      rcvr_shiftreg[1] <= DQ_IN;
910                   2:
911                      rcvr_shiftreg[2] <= DQ_IN;
912                   3:
913                      rcvr_shiftreg[3] <= DQ_IN;
914                   4:
915                      rcvr_shiftreg[4] <= DQ_IN;
916                   5:
917                      rcvr_shiftreg[5] <= DQ_IN;
918                   6:
919                      rcvr_shiftreg[6] <= DQ_IN;
920                   7:
921                      rcvr_shiftreg[7] <= DQ_IN;
922                 endcase
923              if(TimeSlotCnt == bit_ts_writezero_high)            //62 7_25_01
924                 OneWireIO <= WaitTS;
925              if(DQ_IN)
926                 LOW_DONE <= 1;
927             end
928
929           WriteOne:
930             begin
931              TimeSlotCnt <= TimeSlotCnt + 1;
932              if(((TimeSlotCnt==bit_ts_sample) && !sr_a && !LLM) ||
933                 ((TimeSlotCnt==bit_ts_sample_ll) && !sr_a &&  LLM))
934                 case(index)
935                   0:
936                      rcvr_shiftreg[0] <= DQ_IN;
937                   1:
938                      rcvr_shiftreg[1] <= DQ_IN;
939                   2:
940                      rcvr_shiftreg[2] <= DQ_IN;
941                   3:
942                      rcvr_shiftreg[3] <= DQ_IN;
943                   4:
944                      rcvr_shiftreg[4] <= DQ_IN;
945                   5:
946                      rcvr_shiftreg[5] <= DQ_IN;
947                   6:
948                      rcvr_shiftreg[6] <= DQ_IN;
949                   7:
950                      rcvr_shiftreg[7] <= DQ_IN;
951                 endcase
952              if(TimeSlotCnt == bit_ts_writezero_high)             //62 7_25_01
953                 OneWireIO <= WaitTS;
954              if(DQ_IN)
955                 LOW_DONE <= 1;
956             end
957
958           // ADDED ODWRITE states here GAG
959           // ODWriteZero and ODWriteOne are identical, except for what they
960           // do to DQ (assigned in concurrent assignments). They both read
961           // DQ after 3us, then move on to wait for the end of the timeslot.
962           ODWriteZero:
963             begin
964              TimeSlotCnt <= TimeSlotCnt + 1;
965              if((TimeSlotCnt == bit_ts_sample_od) && !sr_a)
966                 case(index)
967                   0:
968                      rcvr_shiftreg[0] <= DQ_IN;
969                   1:
970                      rcvr_shiftreg[1] <= DQ_IN;
971                   2:
972                      rcvr_shiftreg[2] <= DQ_IN;
973                   3:
974                      rcvr_shiftreg[3] <= DQ_IN;
975                   4:
976                      rcvr_shiftreg[4] <= DQ_IN;
977                   5:
978                      rcvr_shiftreg[5] <= DQ_IN;
979                   6:
980                      rcvr_shiftreg[6] <= DQ_IN;
981                   7:
982                      rcvr_shiftreg[7] <= DQ_IN;
983                 endcase
984              if(TimeSlotCnt == bit_ts_writezero_high_od)
985                 OneWireIO <= WaitTS;
986              if(DQ_IN)
987                 LOW_DONE <= 1;
988             end
989
990           ODWriteOne:
991             begin
992              TimeSlotCnt <= TimeSlotCnt + 1;
993              if((TimeSlotCnt == bit_ts_sample_od) && !sr_a)
994                 case(index)
995                   0:
996                      rcvr_shiftreg[0] <= DQ_IN;
997                   1:
998                      rcvr_shiftreg[1] <= DQ_IN;
999                   2:
1000                      rcvr_shiftreg[2] <= DQ_IN;
1001                   3:
1002                      rcvr_shiftreg[3] <= DQ_IN;
1003                   4:
1004                      rcvr_shiftreg[4] <= DQ_IN;
1005                   5:
1006                      rcvr_shiftreg[5] <= DQ_IN;
1007                   6:
1008                      rcvr_shiftreg[6] <= DQ_IN;
1009                   7:
1010                      rcvr_shiftreg[7] <= DQ_IN;
1011                 endcase
1012              if(TimeSlotCnt == bit_ts_writezero_high_od)
1013                OneWireIO <= WaitTS;
1014              if(DQ_IN)
1015                 LOW_DONE <= 1;
1016             end
1017
1018           // ReadBit used by the SRA to do the required bit reads
1019           ReadBit:
1020             begin
1021              TimeSlotCnt <= TimeSlotCnt + 1;
1022              if(DQ_IN)
1023                LOW_DONE <= 1;
1024              if(OD)
1025                begin
1026                  if(TimeSlotCnt == bit_ts_sample_od)
1027                    if(!First)
1028                      BitRead1 <= DQ_IN;
1029                    else
1030                      BitRead2 <= DQ_IN;
1031                  if(TimeSlotCnt == bit_ts_writezero_high_od)     //7 7_25_01
1032                    OneWireIO <= FirstPassSR;
1033                end
1034              else
1035                begin
1036                  if(((TimeSlotCnt == bit_ts_sample)&&!LLM) || ((TimeSlotCnt == bit_ts_sample_ll)&&LLM))
1037                    if(!First)
1038                      BitRead1 <= DQ_IN;
1039                    else
1040                      BitRead2 <= DQ_IN;
1041                  if(TimeSlotCnt == bit_ts_writezero_high)
1042                    OneWireIO <= FirstPassSR;
1043                end
1044             end
1045
1046           // FirstPassSR decides whether to do another read or to do the
1047           // bit write.
1048           FirstPassSR:
1049             begin
1050              TimeSlotCnt <= TimeSlotCnt + 1;
1051              LOW_DONE <= 0;
1052              if(OD)
1053                begin
1054                  if(TimeSlotCnt == bit_ts_end_od)
1055                    begin
1056                      TimeSlotCnt <= 0;
1057                      if(!First)
1058                        begin
1059                          First <= 1'b1;
1060                          OneWireIO <= DQLOW;
1061                        end
1062                      else
1063                        begin
1064                          OneWireIO <= WriteBitSR;
1065                        end
1066                    end
1067                end
1068              else
1069                begin
1070                  if(((TimeSlotCnt==bit_ts_end) && !LLM) || ((TimeSlotCnt==bit_ts_end_ll) && LLM))
1071                    begin
1072                      TimeSlotCnt <= 0;
1073                      if(!First)
1074                        begin
1075                          First <= 1'b1;
1076                          OneWireIO <= DQLOW;
1077                        end
1078                      else
1079                        begin
1080                          OneWireIO <= WriteBitSR;
1081                        end // else: !if(!First)
1082                    end
1083                end
1084             end
1085
1086           // WriteBitSR will now determine the bit necessary to write
1087           // for the Search ROM to proceed.
1088           WriteBitSR:
1089             begin
1090               case({BitRead1,BitRead2})
1091                 2'b00: begin
1092                    case(index)
1093                      0: begin
1094                         BitWrite <= xmit_shiftreg[1];
1095                         rcvr_shiftreg[0] <= 1'b1;
1096                      end
1097                      1: begin
1098                         BitWrite <= xmit_shiftreg[2];
1099                         rcvr_shiftreg[1] <= 1'b1;
1100                      end
1101                      2: begin
1102                         BitWrite <= xmit_shiftreg[3];
1103                         rcvr_shiftreg[2] <= 1'b1;
1104                      end
1105                      3: begin
1106                         BitWrite <= xmit_shiftreg[4];
1107                         rcvr_shiftreg[3] <= 1'b1;
1108                      end
1109                      4: begin
1110                         BitWrite <= xmit_shiftreg[5];
1111                         rcvr_shiftreg[4] <= 1'b1;
1112                      end
1113                      5: begin
1114                         BitWrite <= xmit_shiftreg[6];
1115                         rcvr_shiftreg[5] <= 1'b1;
1116                      end
1117                      6: begin
1118                         BitWrite <= xmit_shiftreg[7];
1119                         rcvr_shiftreg[6] <= 1'b1;
1120                      end
1121                      7: begin
1122                         BitWrite <= xmit_shiftreg[0];
1123                         rcvr_shiftreg[7] <= 1'b1;
1124                      end
1125                    endcase
1126                 end
1127                 2'b01: begin
1128                    BitWrite <= 1'b0;
1129                    case(index)
1130                      0:
1131                         rcvr_shiftreg[0] <= 1'b0;
1132                      1:
1133                         rcvr_shiftreg[1] <= 1'b0;
1134                      2:
1135                         rcvr_shiftreg[2] <= 1'b0;
1136                      3:
1137                         rcvr_shiftreg[3] <= 1'b0;
1138                      4:
1139                         rcvr_shiftreg[4] <= 1'b0;
1140                      5:
1141                         rcvr_shiftreg[5] <= 1'b0;
1142                      6:
1143                         rcvr_shiftreg[6] <= 1'b0;
1144                      7:
1145                         rcvr_shiftreg[7] <= 1'b0;
1146                    endcase
1147                 end
1148                 2'b10: begin
1149                    BitWrite <= 1'b1;
1150                    case(index)
1151                      0:
1152                         rcvr_shiftreg[0] <= 1'b0;
1153                      1:
1154                         rcvr_shiftreg[1] <= 1'b0;
1155                      2:
1156                         rcvr_shiftreg[2] <= 1'b0;
1157                      3:
1158                         rcvr_shiftreg[3] <= 1'b0;
1159                      4:
1160                         rcvr_shiftreg[4] <= 1'b0;
1161                      5:
1162                         rcvr_shiftreg[5] <= 1'b0;
1163                      6:
1164                         rcvr_shiftreg[6] <= 1'b0;
1165                      7:
1166                         rcvr_shiftreg[7] <= 1'b0;
1167                    endcase
1168                 end
1169                 2'b11: begin
1170                    BitWrite <= 1'b1;
1171                    case(index)
1172                      0: begin
1173                         rcvr_shiftreg[0] <= 1'b1;
1174                         rcvr_shiftreg[1] <= 1'b1;
1175                      end
1176                      1: begin
1177                         rcvr_shiftreg[1] <= 1'b1;
1178                         rcvr_shiftreg[2] <= 1'b1;
1179                      end
1180                      2: begin
1181                         rcvr_shiftreg[2] <= 1'b1;
1182                         rcvr_shiftreg[3] <= 1'b1;
1183                      end
1184                      3: begin
1185                         rcvr_shiftreg[3] <= 1'b1;
1186                         rcvr_shiftreg[4] <= 1'b1;
1187                      end
1188                      4: begin
1189                         rcvr_shiftreg[4] <= 1'b1;
1190                         rcvr_shiftreg[5] <= 1'b1;
1191                      end
1192                      5: begin
1193                         rcvr_shiftreg[5] <= 1'b1;
1194                         rcvr_shiftreg[6] <= 1'b1;
1195                      end
1196                      6: begin
1197                         rcvr_shiftreg[6] <= 1'b1;
1198                         rcvr_shiftreg[7] <= 1'b1;
1199                      end
1200                      7: begin
1201                         rcvr_shiftreg[7] <= 1'b1;
1202                         rcvr_shiftreg[0] <= 1'b1;
1203                      end
1204                    endcase
1205                 end
1206               endcase // case({BitRead1,BitRead2})
1207               OneWireIO <= WriteBit;
1208              end
1209
1210           // WriteBit actually writes the chosen bit to the One Wire bus.
1211           WriteBit:
1212             begin
1213              TimeSlotCnt <= TimeSlotCnt + 1;
1214              case(index)
1215                0:
1216                   rcvr_shiftreg[1] <= BitWrite;
1217                1:
1218                   rcvr_shiftreg[2] <= BitWrite;
1219                2:
1220                   rcvr_shiftreg[3] <= BitWrite;
1221                3:
1222                   rcvr_shiftreg[4] <= BitWrite;
1223                4:
1224                   rcvr_shiftreg[5] <= BitWrite;
1225                5:
1226                   rcvr_shiftreg[6] <= BitWrite;
1227                6:
1228                   rcvr_shiftreg[7] <= BitWrite;
1229                7:
1230                   rcvr_shiftreg[0] <= BitWrite;
1231              endcase
1232              if(!BitWrite)
1233                begin
1234                  if(OD)
1235                    OneWireIO <= ODWriteZero;
1236                  else
1237                    OneWireIO <= WriteZero;
1238                end
1239              else
1240                begin
1241                  if(OD && (TimeSlotCnt == bit_ts_writeone_high_od))
1242                    OneWireIO <= ODWriteOne;
1243                  else if (!LLM && (TimeSlotCnt == bit_ts_writeone_high))  //5 7_25_01
1244                    OneWireIO <= WriteOne;
1245                  else if (LLM && (TimeSlotCnt == bit_ts_writeone_high_ll))
1246                    OneWireIO <= WriteOne;
1247                end
1248             end
1249
1250           // WaitTS waits until the timeslot is completed, 80us. When done with
1251           // that timeslot, the index will be incremented.
1252           WaitTS:
1253             begin
1254              SET_IOSHRT <= 0;
1255              TimeSlotCnt <= TimeSlotCnt + 1;
1256              if(OD)
1257                begin
1258                  if(TimeSlotCnt == bit_ts_end_od)  //11 7_25_01
1259                    OneWireIO <= IndexInc;
1260                end
1261              else
1262                if(((TimeSlotCnt == bit_ts_end) && !LLM) || ((TimeSlotCnt==bit_ts_end_ll) && LLM))
1263                  OneWireIO <= IndexInc;
1264              if(DQ_IN)
1265                 LOW_DONE <= 1;
1266             end
1267
1268           // IndexInc incs the index by 1 if normal write, by 2 if in SRA
1269           IndexInc:
1270             begin
1271              if(!sr_a)
1272                 index <= index + 1;
1273              else
1274                 begin
1275                    index <= index + 2;
1276                    First <= 1'b0;
1277                 end
1278
1279              if(BIT_CTL || (index == 8-1 && !sr_a) || (index == 8-2 && sr_a)  )
1280                 begin                             // Added BIT_CTL - GAG
1281                    byte_done <= 1'b1;
1282                    OneWireIO <= UpdateBuff;
1283                 end
1284              else
1285                 begin
1286                    if((index == 7-1) && !sr_a)
1287                       last_rcvr_bit <= 1'b1;
1288                    else
1289                       if((index == 6-2) && sr_a)
1290                          last_rcvr_bit <= 1'b1;
1291                    OneWireIO <= DQLOW;
1292                    TimeSlotCnt <= 0;
1293                 end
1294
1295                 LOW_DONE <= 0;
1296             end
1297
1298           UpdateBuff:
1299             begin
1300                OneWireIO <= IdleS;
1301                if(DQ_IN && STP_SPLY)
1302                  LOW_DONE <= 1;
1303             end
1304         endcase
1305endmodule
Note: See TracBrowser for help on using the repository browser.