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: