Minor: Adjust indentation in DbC body
[libxhcidbg.git] / src / hw-dbc.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
17 with HW.Time;
18 with HW.Debug;
19
20 with HW.DbC.Intel_Quirk;
21 with HW.DbC.DMA_Buffers;
22 with HW.DbC.Transfer_Info;
23 with HW.DbC.Transfer_Rings;
24 with HW.DbC.Transfers;
25 with HW.DbC.Contexts;
26 with HW.DbC.Events;
27 with HW.DbC.TRBs;
28
29 package body HW.DbC
30 with
31    Refined_State => (State => (Connected, Running,
32                                DbC_Run_Deadline, DbC_Poll_Deadline,
33                                DbC_Stat_Deadline, Events.State,
34                                Transfer_Info.State, Transfer_Rings.State),
35                      DMA   => (ERST, DbC_Context, Desc_Strings, Events.DMA,
36                                Transfer_Rings.DMA))
37 is
38
39    Apply_Intel_Quirk : constant Boolean := True;
40    Debug_xCap        : constant Boolean := False;
41
42    Connected         : Boolean;
43    Running           : Boolean;
44    DbC_Run_Deadline  : Time.T;
45    DbC_Poll_Deadline : Time.T;
46    DbC_Stat_Deadline : Time.T;
47
48    ----------------------------------------------------------------------------
49
50    ERST : Events.ERST_Entry
51    with
52       Address => System'To_Address (DMA_Buffers.Event_Ring_Segment_Table_Base);
53
54    DbC_Context : Contexts.DbC_Context
55    with
56       Address => System'To_Address (DMA_Buffers.DbC_Context_Base);
57
58    ----------------------------------------------------------------------------
59
60    subtype Desc_Str_Range is Natural range 0 .. 14;
61    type Desc_Str is array (Desc_Str_Range) of Word16 with Pack;
62    type String_Descriptor is record
63       bLength           : Byte;
64       bDescriptor_Type  : Byte;
65       wData             : Desc_Str;
66    end record with Pack;
67
68    type Desc_Strings_Type is (String0, Manufacturer, Product, Serial_Number);
69    type Desc_Strings_Array is
70       array (Desc_Strings_Type) of String_Descriptor with Pack;
71    Desc_Strings : Desc_Strings_Array
72    with
73       Address => System'To_Address (DMA_Buffers.Descriptor_Strings_Base);
74
75    procedure String_To_Desc (Dst : out String_Descriptor; Src : in String)
76    is
77       use type Byte;
78    begin
79       Dst.bLength := 2 + 2 * Byte'Min (Dst.wData'Length, Src'Length);
80       Dst.bDescriptor_Type := 16#03#;
81       for I in Desc_Str_Range loop
82          if I < Src'Last then
83             Dst.wData (I) := Character'Pos (Src (I + 1));
84          else
85             Dst.wData (I) := 16#0000#;
86          end if;
87       end loop;
88    end String_To_Desc;
89
90    ----------------------------------------------------------------------------
91
92    procedure Find_Next_xCap (Cap_Id : in Word8; Success : out Boolean)
93    is
94       use type Word8;
95       use type Word32;
96       Current_Id : Word8;
97       Temp_Offset : Word32;
98    begin
99       Success := False;
100       if xCap_Regs.Byte_Offset = 0 then
101          Cap_Regs.Read (Temp_Offset, XHCI_Extended_Caps);
102       else
103          xCap_Regs.Read (Temp_Offset, Next_xCap);
104       end if;
105       loop
106          Temp_Offset := Shift_Left (Temp_Offset, 2);
107          pragma Debug (Debug_xCap, Debug.Put_Reg32
108            ("Find_Next_xCap Offset", Temp_Offset));
109          exit when
110             Temp_Offset = 0 or else
111             xCap_Regs.Byte_Offset > MMIO_Size - Natural (Temp_Offset) - 2;
112
113          xCap_Regs.Byte_Offset := xCap_Regs.Byte_Offset + Natural (Temp_Offset);
114
115          xCap_Regs.Read (Current_Id, Capability_ID);
116          Success := Current_Id = Cap_Id;
117          pragma Debug (Debug_xCap, Debug.Put_Reg8
118            ("Find_Next_xCap Cap_Id", Current_Id));
119          exit when Success;
120
121          xCap_Regs.Read (Temp_Offset, Next_xCap);
122       end loop;
123    end Find_Next_xCap;
124
125    ----------------------------------------------------------------------------
126
127    procedure BIOS_Handover (Success : out Boolean)
128    is
129       use type Word8;
130       BIOS_Owned  : Word8;
131       Deadline    : Time.T;
132    begin
133       xCap_Regs.Byte_Offset := 0;
134       Find_Next_xCap (1, Success);
135       if Success then
136          Legacy_Support_Regs.Byte_Offset := xCap_Regs.Byte_Offset;
137          -- See if the BIOS claims ownership
138          Legacy_Support_Regs.Read (BIOS_Owned, HC_BIOS_Owned_Semaphore);
139          if BIOS_Owned = 1 then
140             pragma Debug (Debug.Put_Line ("DbC: BIOS claims ownership."));
141
142             Legacy_Support_Regs.Write (HC_OS_Owned_Semaphore, Word8'(1));
143
144             Deadline := Time.MS_From_Now (5_000);
145             loop
146                Legacy_Support_Regs.Read (BIOS_Owned, HC_BIOS_Owned_Semaphore);
147                exit when BIOS_Owned = 0;
148                declare
149                   Timeout : constant Boolean := Time.Timed_Out (Deadline);
150                begin
151                   Success := not Timeout;
152                end;
153                exit when not Success;
154                pragma Warnings (GNATprove, Off, "statement has no effect");
155                for I in 0 .. 1234 loop
156                   null; -- Busy loop to reduce pressure on HC BIOS Owned
157                         -- Semaphore. It shouldn't generate an SMI but
158                         -- might congest the xHC?
159                end loop;
160                pragma Warnings (GNATprove, On, "statement has no effect");
161             end loop;
162
163             pragma Debug (not Success, Debug.Put_Line
164               ("ERROR: BIOS didn't hand over xHC within 5s."));
165             pragma Debug (Success, Debug.Put_Line
166               ("DbC: BIOS hand-over succeeded."));
167          end if;
168       end if;
169    end BIOS_Handover;
170
171    procedure Reset (Initial_Reset : Boolean := False);
172
173    procedure Init
174    is
175       use type Word8;
176       CNR : Word8;
177       Deadline : Time.T;
178       Success : Boolean;
179       Cap_Length : Word8;
180    begin
181       Cap_Regs.Read (Cap_Length, Capability_Registers_Length);
182       Op_Regs.Byte_Offset := Natural (Cap_Length);
183
184       Op_Regs.Read (CNR, Controller_Not_Ready);
185       Success := CNR = 0;
186
187       if not Success then
188          pragma Debug (Debug.Put_Line ("WARNING: xHCI not ready!"));
189          Deadline := Time.MS_From_Now (1_000);
190          Success := True;
191          loop
192             Op_Regs.Read (CNR, Controller_Not_Ready);
193             exit when CNR = 0;
194             declare
195                Timed_Out : constant Boolean := Time.Timed_Out (Deadline);
196             begin
197                Success := not Timed_Out;
198             end;
199             exit when not Success;
200          end loop;
201          pragma Debug (not Success, Debug.Put_Line
202            ("ERROR: xHC not ready after 1s."));
203       end if;
204
205       if Success then
206          BIOS_Handover (Success);
207       end if;
208
209       if Success then
210          xCap_Regs.Byte_Offset := 0;
211          Find_Next_xCap (10, Success);
212       end if;
213
214       pragma Debug (not Success, Debug.Put_Line
215                     ("ERROR: Couldn't find xHCI debug capability."));
216
217       if Success then
218          Regs.Byte_Offset := xCap_Regs.Byte_Offset;
219
220          ERST := Events.ERST_Entry'
221            (Segment_Base   => DMA_Buffers.Event_Ring_Base,
222             Segment_Size   => TRBs.TRBs_Per_Ring,
223             Reserved_Z     => 0);
224
225          Desc_Strings (String0).bLength            := 16#04#;
226          Desc_Strings (String0).bDescriptor_Type   := 16#03#;
227          Desc_Strings (String0).wData := (0 => 16#0409#, others => 16#0000#);
228          String_To_Desc (Desc_Strings (Manufacturer), "secunet");
229          String_To_Desc (Desc_Strings (Product), "HW.DbC");
230          String_To_Desc (Desc_Strings (Serial_Number), "1");
231
232          Reset (Initial_Reset => True);
233       end if;
234    end Init;
235
236    ----------------------------------------------------------------------------
237
238    procedure Reset (Initial_Reset : Boolean := False)
239    is
240       use type Word8;
241       use type Word16;
242       use type Word64;
243       DCE,
244       MBS : Word8;
245    begin
246       if Regs.Byte_Offset /= 0 then
247          Regs.Write (DbC_Enable, Word8'(0));
248          loop
249             Regs.Read (DCE, DbC_Enable);
250             exit when DCE = 0;
251          end loop;
252
253          Transfers.Reset (Initial_Reset);
254
255          Regs.Write (ERST_Size, Word16'(1));
256          Regs.Write (ERST_Base_Lo, Word32
257            (DMA_Buffers.Event_Ring_Segment_Table_Base mod 16#1_0000_0000#));
258          Regs.Write (ERST_Base_Hi, Word32
259            (DMA_Buffers.Event_Ring_Segment_Table_Base  /  16#1_0000_0000#));
260          Events.Reset_Ring;
261
262          Regs.Write (ER_Dequeue_Ptr_Lo, Word32
263            (DMA_Buffers.Event_Ring_Base mod 16#1_0000_0000#));
264          Regs.Write (ER_Dequeue_Ptr_Hi, Word32
265            (DMA_Buffers.Event_Ring_Base  /  16#1_0000_0000#));
266
267          Regs.Write (Context_Pointer_Lo, Word32
268            (DMA_Buffers.DbC_Context_Base mod 16#1_0000_0000#));
269          Regs.Write (Context_Pointer_Hi, Word32
270            (DMA_Buffers.DbC_Context_Base  /  16#1_0000_0000#));
271
272          Contexts.Clear_DbC_Context (DbC_Context);
273          DbC_Context.DbC_Info :=
274            (String_0_Address              => DMA_Buffers.Descriptor_Strings_Base,
275             Manufacturer_String_Address   => DMA_Buffers.Descriptor_Strings_Base
276                                              + 1 * String_Descriptor'Size / 8,
277             Product_String_Address        => DMA_Buffers.Descriptor_Strings_Base
278                                              + 2 * String_Descriptor'Size / 8,
279             Serial_Number_String_Address  => DMA_Buffers.Descriptor_Strings_Base
280                                              + 3 * String_Descriptor'Size / 8,
281             String_0_Length               => Desc_Strings (String0).bLength,
282             Manufacturer_String_Length    => Desc_Strings (Manufacturer).bLength,
283             Product_String_Length         => Desc_Strings (Product).bLength,
284             Serial_Number_String_Length   => Desc_Strings (Serial_Number).bLength,
285             Reserved_Z                    => 0,
286             others                        => 0);
287
288          Regs.Read (MBS, Debug_Max_Burst_Size);
289          DbC_Context.OUT_EP.EP_Type                := Contexts.Bulk_O;
290          DbC_Context.OUT_EP.Max_Burst_Size         := MBS;
291          DbC_Context.OUT_EP.Max_Packet_Size        := 1024;
292          DbC_Context.OUT_EP.TR_Dequeue_Pointer_Lo  := Word28
293            (Shift_Right (Transfer_Rings.Physical (2),  4) and 16#0fff_ffff#);
294          DbC_Context.OUT_EP.TR_Dequeue_Pointer_Hi  := Word32
295            (Shift_Right (Transfer_Rings.Physical (2), 32) and 16#ffff_ffff#);
296          DbC_Context.OUT_EP.Dequeue_Cycle_State    := 1;
297          DbC_Context.OUT_EP.Average_TRB_Length     := Max_Bulk_Size / 2;
298          DbC_Context.IN_EP.EP_Type                 := Contexts.Bulk_I;
299          DbC_Context.IN_EP.Max_Burst_Size          := MBS;
300          DbC_Context.IN_EP.Max_Packet_Size         := 1024;
301          DbC_Context.IN_EP.TR_Dequeue_Pointer_Lo   := Word28
302            (Shift_Right (Transfer_Rings.Physical (3),  4) and 16#0fff_ffff#);
303          DbC_Context.IN_EP.TR_Dequeue_Pointer_Hi   := Word32
304            (Shift_Right (Transfer_Rings.Physical (3), 32) and 16#ffff_ffff#);
305          DbC_Context.IN_EP.Dequeue_Cycle_State     := 1;
306          DbC_Context.IN_EP.Average_TRB_Length      := Max_Bulk_Size / 2;
307
308          Regs.Write (DbC_Protocol, Word16'(0));  -- Debug Target vendor defined.
309          Regs.Write (Vendor_ID, Word16 (16#ffff#));
310          Regs.Write (Product_ID, Word16 (16#dbc1#));
311          Regs.Write (Device_Revision, Word16 (16#0001#));
312
313          Regs.Write (DbC_Enable, Word8'(1));
314          loop
315             Regs.Read (DCE, DbC_Enable);
316             exit when DCE = 1;
317          end loop;
318
319          if Apply_Intel_Quirk then
320             Intel_Quirk.Reset_Port;
321          end if;
322
323          Running := False;
324          Connected := False;
325          DbC_Poll_Deadline := Time.Now;
326          DbC_Stat_Deadline := Time.MS_From_Now (12_345);
327       end if;
328    end Reset;
329
330    procedure Poll (Now : Boolean := False)
331    is
332       use type Word8;
333
334       Temp8 : Word8;
335       Timed_Out : Boolean;
336    begin
337       if Regs.Byte_Offset /= 0 then
338          Timed_Out := Time.Timed_Out (DbC_Poll_Deadline);
339          if Now or else Timed_Out then
340             Regs.Read (Temp8, DbC_Enable);
341             if Temp8 = 1 then
342                Regs.Read (Temp8, Current_Connect_Status);
343                if Temp8 = 1 then
344                   -- Something is connected...
345                   DbC_Poll_Deadline := Time.MS_From_Now (10);
346                   if not Connected then
347                      pragma Debug (Debug.Put_Line ("DbC connected."));
348                      DbC_Run_Deadline := Time.MS_From_Now (333);
349                      Connected := True;
350                   end if;
351                   Regs.Read (Temp8, DbC_Run);
352                   if Temp8 = 1 then
353                      -- ...configured too
354                      if not Running then
355                         pragma Debug (Debug.Put_Line ("DbC configured."));
356                         Transfers.Start;
357                         Running := True;
358                      end if;
359                   elsif Running then
360                      pragma Debug (Debug.Put_Line
361                        ("DbC still connected but deconfigured."));
362                      DbC_Run_Deadline := Time.MS_From_Now (333);
363                      Running := False;
364                   else
365                      Timed_Out := Time.Timed_Out (DbC_Run_Deadline);
366                      if Timed_Out then
367                         pragma Debug (Debug.Put_Line
368                           ("DbC connection timed out."));
369                         Reset;
370                      end if;
371                   end if;
372                else
373                   -- Nothing connected
374                   DbC_Poll_Deadline := Time.MS_From_Now (333);
375                   if Connected then
376                      pragma Debug (Debug.Put_Line ("DbC disconnected."));
377                      Connected := False;
378                      Running := False;
379                   end if;
380                end if;
381             else
382                pragma Debug (Debug.Put_Line ("DbC got disabled, huh?"));
383                Reset;
384             end if;
385             Events.Handle_Events;
386             Timed_Out := Time.Timed_Out (DbC_Stat_Deadline);
387             if Timed_Out then
388                pragma Debug (Transfer_Info.Dump_Stats);
389                DbC_Stat_Deadline := Time.MS_From_Now (12_345);
390             end if;
391          end if;
392       end if;
393    end Poll;
394
395    procedure Receive (Buf : in out Buffer; Len : in out Natural)
396    is
397    begin
398       Poll (Now => True);
399
400       Transfers.Receive (Buf, Len);
401    end Receive;
402
403    procedure Send (Buf : Buffer; Len : in out Natural; Success : out Boolean)
404    is
405    begin
406       Poll (Now => True);
407
408       Transfers.Send
409         (Buf         => Buf,
410          Len         => Len,
411          Start_Now   => Running,
412          Success     => Success);
413    end Send;
414
415    procedure Ring_Doorbell (EP : Endpoint_Range)
416    is
417       use type Word8;
418    begin
419       Regs.Write (Doorbell_Target, Word8 (EP) - 2);
420    end Ring_Doorbell;
421
422 end HW.DbC;
423
424 --  vim: set ts=8 sts=3 sw=3 et: