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: