ea4f228e449a2d52f6d1f8718f9c82bb9eaedf79
[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,
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                for I in 0 .. 1234 loop
155                   null; -- Busy loop to reduce pressure on HC BIOS Owned
156                         -- Semaphore. It shouldn't generate an SMI but
157                         -- might congest the xHC?
158                end loop;
159             end loop;
160
161             pragma Debug (not Success, Debug.Put_Line
162               ("ERROR: BIOS didn't hand over xHC within 5s."));
163             pragma Debug (Success, Debug.Put_Line
164               ("DbC: BIOS hand-over succeeded."));
165          end if;
166       end if;
167    end BIOS_Handover;
168
169    procedure Reset (Initial_Reset : Boolean := False);
170
171    procedure Init
172    is
173       use type Word8;
174       CNR : Word8;
175       Deadline : Time.T;
176       Success : Boolean;
177       Cap_Length : Word8;
178    begin
179       Cap_Regs.Read (Cap_Length, Capability_Registers_Length);
180       Op_Regs.Byte_Offset := Natural (Cap_Length);
181
182       Op_Regs.Read (CNR, Controller_Not_Ready);
183       Success := CNR = 0;
184
185       if not Success then
186          pragma Debug (Debug.Put_Line ("WARNING: xHCI not ready!"));
187          Deadline := Time.MS_From_Now (1_000);
188          Success := True;
189          loop
190             Op_Regs.Read (CNR, Controller_Not_Ready);
191             exit when CNR = 0;
192             Success := not Time.Timed_Out (Deadline);
193             exit when not Success;
194          end loop;
195          pragma Debug (not Success, Debug.Put_Line
196            ("ERROR: xHC not ready after 1s."));
197       end if;
198
199       if Success then
200          BIOS_Handover (Success);
201       end if;
202
203       if Success then
204          xCap_Regs.Byte_Offset := 0;
205          Find_Next_xCap (10, Success);
206       end if;
207
208       pragma Debug (not Success, Debug.Put_Line
209                     ("ERROR: Couldn't find xHCI debug capability."));
210
211       if Success then
212          Regs.Byte_Offset := xCap_Regs.Byte_Offset;
213
214          ERST := Events.ERST_Entry'
215            (Segment_Base   => DMA_Buffers.Event_Ring_Base,
216             Segment_Size   => TRBs.TRBs_Per_Ring,
217             Reserved_Z     => 0);
218
219          Desc_Strings (String0).bLength            := 16#04#;
220          Desc_Strings (String0).bDescriptor_Type   := 16#03#;
221          Desc_Strings (String0).wData := (0 => 16#0409#, others => 16#0000#);
222          String_To_Desc (Desc_Strings (Manufacturer), "secunet");
223          String_To_Desc (Desc_Strings (Product), "HW.DbC");
224          String_To_Desc (Desc_Strings (Serial_Number), "1");
225
226          Reset (Initial_Reset => True);
227       end if;
228    end Init;
229
230    ----------------------------------------------------------------------------
231
232    procedure Reset (Initial_Reset : Boolean := False)
233    is
234       use type Word8;
235       use type Word16;
236       use type Word64;
237       DCE,
238       MBS : Word8;
239    begin
240       if Regs.Byte_Offset /= 0 then
241          Regs.Write (DbC_Enable, Word8'(0));
242          loop
243             Regs.Read (DCE, DbC_Enable);
244             exit when DCE = 0;
245          end loop;
246
247          Transfers.Reset (Initial_Reset);
248
249          Regs.Write (ERST_Size, Word16'(1));
250          Regs.Write (ERST_Base_Lo, Word32
251            (DMA_Buffers.Event_Ring_Segment_Table_Base mod 16#1_0000_0000#));
252          Regs.Write (ERST_Base_Hi, Word32
253            (DMA_Buffers.Event_Ring_Segment_Table_Base  /  16#1_0000_0000#));
254          Events.Reset_Ring;
255
256          Regs.Write (ER_Dequeue_Ptr_Lo, Word32
257            (DMA_Buffers.Event_Ring_Base mod 16#1_0000_0000#));
258          Regs.Write (ER_Dequeue_Ptr_Hi, Word32
259            (DMA_Buffers.Event_Ring_Base  /  16#1_0000_0000#));
260
261          Regs.Write (Context_Pointer_Lo, Word32
262            (DMA_Buffers.DbC_Context_Base mod 16#1_0000_0000#));
263          Regs.Write (Context_Pointer_Hi, Word32
264            (DMA_Buffers.DbC_Context_Base  /  16#1_0000_0000#));
265
266          Contexts.Clear_DbC_Context (DbC_Context);
267          DbC_Context.DbC_Info :=
268            (String_0_Address              => DMA_Buffers.Descriptor_Strings_Base,
269             Manufacturer_String_Address   => DMA_Buffers.Descriptor_Strings_Base
270                                              + 1 * String_Descriptor'Size / 8,
271             Product_String_Address        => DMA_Buffers.Descriptor_Strings_Base
272                                              + 2 * String_Descriptor'Size / 8,
273             Serial_Number_String_Address  => DMA_Buffers.Descriptor_Strings_Base
274                                              + 3 * String_Descriptor'Size / 8,
275             String_0_Length               => Desc_Strings (String0).bLength,
276             Manufacturer_String_Length    => Desc_Strings (Manufacturer).bLength,
277             Product_String_Length         => Desc_Strings (Product).bLength,
278             Serial_Number_String_Length   => Desc_Strings (Serial_Number).bLength,
279             Reserved_Z                    => 0,
280             others                        => 0);
281
282          Regs.Read (MBS, Debug_Max_Burst_Size);
283          DbC_Context.OUT_EP.EP_Type                := Contexts.Bulk_O;
284          DbC_Context.OUT_EP.Max_Burst_Size         := MBS;
285          DbC_Context.OUT_EP.Max_Packet_Size        := 1024;
286          DbC_Context.OUT_EP.TR_Dequeue_Pointer_Lo  := Word28
287            (Shift_Right (Transfer_Rings.Physical (2),  4) and 16#0fff_ffff#);
288          DbC_Context.OUT_EP.TR_Dequeue_Pointer_Hi  := Word32
289            (Shift_Right (Transfer_Rings.Physical (2), 32) and 16#ffff_ffff#);
290          DbC_Context.OUT_EP.Dequeue_Cycle_State    := 1;
291          DbC_Context.OUT_EP.Average_TRB_Length     := Max_Bulk_Size / 2;
292          DbC_Context.IN_EP.EP_Type                 := Contexts.Bulk_I;
293          DbC_Context.IN_EP.Max_Burst_Size          := MBS;
294          DbC_Context.IN_EP.Max_Packet_Size         := 1024;
295          DbC_Context.IN_EP.TR_Dequeue_Pointer_Lo   := Word28
296            (Shift_Right (Transfer_Rings.Physical (3),  4) and 16#0fff_ffff#);
297          DbC_Context.IN_EP.TR_Dequeue_Pointer_Hi   := Word32
298            (Shift_Right (Transfer_Rings.Physical (3), 32) and 16#ffff_ffff#);
299          DbC_Context.IN_EP.Dequeue_Cycle_State     := 1;
300          DbC_Context.IN_EP.Average_TRB_Length      := Max_Bulk_Size / 2;
301
302          Regs.Write (DbC_Protocol, Word16'(0));  -- Debug Target vendor defined.
303          Regs.Write (Vendor_ID, Word16 (16#ffff#));
304          Regs.Write (Product_ID, Word16 (16#dbc1#));
305          Regs.Write (Device_Revision, Word16 (16#0001#));
306
307          Regs.Write (DbC_Enable, Word8'(1));
308          loop
309             Regs.Read (DCE, DbC_Enable);
310             exit when DCE = 1;
311          end loop;
312
313          if Apply_Intel_Quirk then
314             Intel_Quirk.Reset_Port;
315          end if;
316
317          Running := False;
318          Connected := False;
319          DbC_Poll_Deadline := Time.Now;
320          DbC_Stat_Deadline := Time.MS_From_Now (12_345);
321       end if;
322    end Reset;
323
324    procedure Poll (Now : Boolean := False)
325    is
326       use type Word8;
327
328       Temp8 : Word8;
329       Timed_Out : Boolean;
330    begin
331       if Regs.Byte_Offset /= 0 then
332          Timed_Out := Now or else Time.Timed_Out (DbC_Poll_Deadline);
333          if Timed_Out then
334             Regs.Read (Temp8, DbC_Enable);
335             if Temp8 = 1 then
336                Regs.Read (Temp8, Current_Connect_Status);
337                if Temp8 = 1 then
338                   -- Something is connected...
339                   DbC_Poll_Deadline := Time.MS_From_Now (10);
340                   if not Connected then
341                      pragma Debug (Debug.Put_Line ("DbC connected."));
342                      DbC_Run_Deadline := Time.MS_From_Now (333);
343                      Connected := True;
344                   end if;
345                   Regs.Read (Temp8, DbC_Run);
346                   if Temp8 = 1 then
347                      -- ...configured too
348                      if not Running then
349                         pragma Debug (Debug.Put_Line ("DbC configured."));
350                         Transfers.Start;
351                         Running := True;
352                      end if;
353                   elsif Running then
354                      pragma Debug (Debug.Put_Line
355                        ("DbC still connected but deconfigured."));
356                      DbC_Run_Deadline := Time.MS_From_Now (333);
357                      Running := False;
358                   else
359                      Timed_Out := Time.Timed_Out (DbC_Run_Deadline);
360                      if Timed_Out then
361                         pragma Debug (Debug.Put_Line
362                           ("DbC connection timed out."));
363                         Reset;
364                      end if;
365                   end if;
366                else
367                   -- Nothing connected
368                   DbC_Poll_Deadline := Time.MS_From_Now (333);
369                   if Connected then
370                      pragma Debug (Debug.Put_Line ("DbC disconnected."));
371                      Connected := False;
372                      Running := False;
373                   end if;
374                end if;
375             else
376                pragma Debug (Debug.Put_Line ("DbC got disabled, huh?"));
377                Reset;
378             end if;
379             Events.Handle_Events;
380             Timed_Out := Time.Timed_Out (DbC_Stat_Deadline);
381             if Timed_Out then
382                pragma Debug (Transfer_Info.Dump_Stats);
383                DbC_Stat_Deadline := Time.MS_From_Now (12_345);
384             end if;
385          end if;
386       end if;
387    end Poll;
388
389    procedure Receive (Buf : in out Buffer; Len : in out Natural)
390    is
391    begin
392       Poll (Now => True);
393
394       Transfers.Receive (Buf, Len);
395    end Receive;
396
397    procedure Send (Buf : Buffer; Len : in out Natural; Success : out Boolean)
398    is
399    begin
400       Poll (Now => True);
401
402       Transfers.Send
403         (Buf         => Buf,
404          Len         => Len,
405          Start_Now   => Running,
406          Success     => Success);
407    end Send;
408
409    procedure Ring_Doorbell (EP : Endpoint_Range)
410    is
411       use type Word8;
412    begin
413       Regs.Write (Doorbell_Target, Word8 (EP) - 2);
414    end Ring_Doorbell;
415
416 end HW.DbC;
417
418 --  vim: set ts=8 sts=3 sw=3 et: