Do not perform hardware reset
[libxhcidbg.git] / src / hw-dbc-transfer_rings.adb
1 --
2 -- Copyright (C) 2016-2017 secunet Security Networks AG
3 --
4 -- This program is free software; you can redistribute it and/or modify
5 -- it under the terms of the GNU General Public License as published by
6 -- the Free Software Foundation; either version 2 of the License, or
7 -- (at your option) any later version.
8 --
9 -- This program is distributed in the hope that it will be useful,
10 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
11 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 -- GNU General Public License for more details.
13 --
14
15 with System;
16 with System.Storage_Elements;
17
18 with HW.Debug;
19 with HW.DbC.DMA_Buffers;
20 with HW.DbC.Transfer_Info;
21 with HW.DbC.TRBs;
22
23 package body HW.DbC.Transfer_Rings
24 with
25    Refined_State =>
26      (State => (PCS, Pointers),
27       DMA   => (Rings))
28 is
29
30    type Transfer_Ring_Array is array (Endpoint_Range) of TRBs.Transfer_Ring
31    with
32       Pack;
33    Rings : Transfer_Ring_Array
34    with
35       Volatile,
36       Async_Readers,
37       Async_Writers,
38       Address => System'To_Address (DMA_Buffers.Transfer_Rings_Base);
39
40    type PCS_Array is array (Endpoint_Range) of Bit;
41    PCS : PCS_Array;
42
43    type Transfer_Pointers is record
44       Enqueue  : TRBs.Ring_Range;
45       Dequeue  : TRBs.Ring_Range;
46       Full     : Boolean;
47       Toggle   : TRBs.Ring_Range;
48       Overrun  : Boolean;
49    end record;
50    type Transfer_Pointers_Array is array (Endpoint_Range) of Transfer_Pointers;
51    Pointers : Transfer_Pointers_Array;
52
53    --  Returns the physical address of the transfer ring specified by given EP.
54    function Get_Ring_Address (EP : Endpoint_Range) return Word64;
55
56    ----------------------------------------------------------------------------
57
58    function Physical (EP : Endpoint_Range) return Word64
59    is
60    begin
61       return
62          DMA_Buffers.Transfer_Rings_Base + (Word64 (EP) - 2) * TRBs.Ring_Size;
63    end Physical;
64
65    function Full (EP : Endpoint_Range) return Boolean
66    is
67    begin
68       return Pointers (EP).Full;
69    end Full;
70
71    function Last_Started (EP : Endpoint_Range) return Boolean
72    is
73       use type TRBs.Ring_Range;
74    begin
75       return
76          not Pointers (EP).Overrun and
77          Pointers (EP).Toggle = Pointers (EP).Enqueue;
78    end Last_Started;
79
80    function Get_Ring_Address (EP : Endpoint_Range) return Word64
81    with SPARK_Mode => Off
82    is
83    begin
84       return Word64
85         (System.Storage_Elements.To_Integer (Rings (EP)'Address));
86    end Get_Ring_Address;
87
88    ----------------------------------------------------------------------------
89
90    procedure Initialize (EP : Endpoint_Range)
91    is
92    begin
93       pragma Debug (Debug.Put ("Initializing Transfer_Ring at "));
94       pragma Debug (Debug.Put_Word64 (Get_Ring_Address (EP)));
95       pragma Debug (Debug.Put (" (phys: "));
96       pragma Debug (Debug.Put_Word64 (Physical (EP)));
97       pragma Debug (Debug.Put_Line (")"));
98       TRBs.Init_Cycle_Ring
99         (Physical => Physical (EP),
100          Ring     => Rings (EP));
101
102       PCS (EP)       := 1;
103       Pointers (EP)  := Transfer_Pointers'
104         (Enqueue => TRBs.Ring_Range'First,
105          Dequeue => TRBs.Ring_Range'First,
106          Full    => False,
107          Toggle  => TRBs.Ring_Range'First,
108          Overrun => False);
109    end Initialize;
110
111    ----------------------------------------------------------------------------
112
113    procedure Toggle_CS (EP : Endpoint_Range)
114    is
115       use type TRBs.Ring_Range;
116       Toggle : TRBs.Ring_Range;
117    begin
118       Toggle := Pointers (EP).Toggle;
119       while Toggle /= Pointers (EP).Enqueue or Pointers (EP).Overrun loop
120          TRBs.Set_Cycle (Rings (EP) (Toggle), PCS (EP));
121          if Toggle = TRBs.Ring_Range'Last then
122             PCS (EP) := 1 - PCS (EP);
123          end if;
124          Toggle := Toggle + 1;
125
126          Pointers (EP).Overrun := False;
127       end loop;
128       Pointers (EP).Toggle := Toggle;
129    end Toggle_CS;
130
131    ----------------------------------------------------------------------------
132
133    function Prev (Current : TRBs.Ring_Range) return TRBs.Ring_Range
134    is
135       use type TRBs.Ring_Range;
136    begin
137       return Current - (if Current = TRBs.Ring_Range'First then 2 else 1);
138    end Prev;
139
140    function Next (Current : TRBs.Ring_Range) return TRBs.Ring_Range
141    is
142       use type TRBs.Ring_Range;
143    begin
144       return Current + (if Current + 1 = TRBs.Ring_Range'Last then 2 else 1);
145    end Next;
146
147    procedure Enqueue_TRB (EP : Endpoint_Range)
148    is
149       use type TRBs.Ring_Range;
150    begin
151       Pointers (EP).Enqueue := Next (Pointers (EP).Enqueue);
152       if Pointers (EP).Enqueue = Pointers (EP).Toggle then
153          Pointers (EP).Overrun := True;
154       end if;
155       if Pointers (EP).Enqueue = Pointers (EP).Dequeue then
156          Pointers (EP).Full := True;
157       end if;
158    end Enqueue_TRB;
159
160    procedure Dequeue_TRB (EP : Endpoint_Range)
161    is
162    begin
163       Pointers (EP).Dequeue := Next (Pointers (EP).Dequeue);
164       Pointers (EP).Full := False;
165    end Dequeue_TRB;
166
167    ----------------------------------------------------------------------------
168
169    procedure Dequeue
170      (EP                : Endpoint_Range;
171       Pointer           : Word64;
172       Status            : Error;
173       Remaining_Length  : Natural)
174    is
175       use type TRBs.TRB_Types;
176       use type TRBs.Ring_Range;
177       Current : TRBs.Ring_Range;
178       Invalid : Boolean;
179    begin
180       if Physical (EP) <= Pointer and
181          Pointer - Physical (EP) < TRBs.Ring_Size and
182          (Pointer - Physical (EP)) mod TRBs.TRB_Size = 0
183       then
184          Current := TRBs.Ring_Range
185            ((Pointer - Physical (EP)) / TRBs.TRB_Size);
186
187          if Pointers (EP).Dequeue < Pointers (EP).Enqueue then
188             Invalid :=
189                Current >= Pointers (EP).Enqueue or
190                Current < Pointers (EP).Dequeue;
191          else
192             Invalid :=
193                Current >= Pointers (EP).Enqueue and
194                Current < Pointers (EP).Dequeue;
195          end if;
196          Invalid := Invalid or Current = TRBs.Ring_Range'Last;
197       else
198          Current := TRBs.Ring_Range'First;
199          Invalid := True;
200       end if;
201
202       if not Invalid then
203          while Pointers (EP).Dequeue /= Current loop
204             -- Finish transfers that have been skipped by the controller
205             pragma Debug (Debug.Put_Line ("WARNING: Skipped TD."));
206             Transfer_Info.Finish
207               (DMA_Physical      => TRBs.Get_Parameter
208                                       (Rings (EP) (Pointers (EP).Dequeue)),
209                Status            => Controller_Error,
210                Remaining_Length  => Max_Bulk_Size);
211             Dequeue_TRB (EP);
212          end loop;
213          Transfer_Info.Finish
214            (DMA_Physical      => TRBs.Get_Parameter (Rings (EP) (Current)),
215             Status            => Status,
216             Remaining_Length  => Remaining_Length);
217          Dequeue_TRB (EP);
218       end if;
219
220       pragma Debug (Invalid, Debug.Put_Reg64
221         ("WARNING: Invalid dequeue pointer", Pointer));
222       pragma Debug (Invalid, Debug.Put_Reg64
223         ("                   Ring physical", Physical (EP)));
224       pragma Debug (Invalid, Debug.Put ("Enqueue: "));
225       pragma Debug (Invalid, Debug.Put_Int32 (Int32 (Pointers (EP).Enqueue)));
226       pragma Debug (Invalid, Debug.Put ("; Dequeue: "));
227       pragma Debug (Invalid, Debug.Put_Int32 (Int32 (Pointers (EP).Dequeue)));
228       pragma Debug (Invalid, Debug.Put ("; Current: "));
229       pragma Debug (Invalid, Debug.Put_Int32 (Int32 (Current)));
230       pragma Debug (Invalid, Debug.New_Line);
231    end Dequeue;
232
233    ----------------------------------------------------------------------------
234
235    procedure Enqueue_Data_TRB
236      (EP                : Endpoint_Range;
237       Data_Length       : Natural;
238       Data_Buf          : Word64;
239       Toggle_CS         : Boolean)
240    is
241       Current : TRBs.Ring_Range;
242    begin
243       Current := Pointers (EP).Enqueue;
244
245       TRBs.Clear (Rings (EP) (Current), PCS (EP));
246       TRBs.Set_Parameter (Rings (EP) (Current), Data_Buf);
247       TRBs.Set_Length (Rings (EP) (Current), Data_Length);
248
249       TRBs.Set_Type (Rings (EP) (Current), TRBs.Normal);
250       TRBs.Set_IOC (Rings (EP) (Current));
251       TRBs.Set_ISP (Rings (EP) (Current));
252
253       Enqueue_TRB (EP);
254       if Toggle_CS then
255          Transfer_Rings.Toggle_CS (EP);
256       end if;
257    end Enqueue_Data_TRB;
258
259    procedure Requeue_Data_TRB
260      (EP       : Endpoint_Range;
261       Length   : Natural;
262       Buf_Addr : Word64)
263    is
264    begin
265       Pointers (EP).Enqueue := Prev (Pointers (EP).Enqueue);
266       Enqueue_Data_TRB (EP, Length, Buf_Addr, False);
267    end Requeue_Data_TRB;
268
269 end HW.DbC.Transfer_Rings;
270
271 --  vim: set ts=8 sts=3 sw=3 et: