Modules/USB/Core/usb_lowlevel.c

   1 /*
   2  * Acess 2 USB Stack
   3  * - By John Hodge (thePowersGang)
   4  *
   5  * usb_lowlevel.c
   6  * - Low Level IO
   7  */
   8 #define DEBUG   1
   9 #include <acess.h>
  10 #include "usb.h"
  11 #include "usb_proto.h"
  12 #include "usb_lowlevel.h"
  13
  14 // === PROTOTYPES ===
  15  int    USB_int_SendSetupSetAddress(tUSBHost *Host, int Address);
  16  int    USB_int_ReadDescriptor(tUSBDevice *Dev, int Endpoint, int Type, int Index, int Length, void *Dest);
  17 char    *USB_int_GetDeviceString(tUSBDevice *Dev, int Endpoint, int Index);
  18  int    _UTF16to8(Uint16 *Input, int InputLen, char *Dest);
  19
  20 // === CODE ===
  21 void *USB_int_Request(tUSBHost *Host, int Addr, int EndPt, int Type, int Req, int Val, int Indx, int Len, void *Data)
  22 {
  23         void    *hdl;
  24         // TODO: Sanity check (and check that Type is valid)
  25         struct sDeviceRequest   req;
  26         req.ReqType = Type;
  27         req.Request = Req;
  28         req.Value = LittleEndian16( Val );
  29         req.Index = LittleEndian16( Indx );
  30         req.Length = LittleEndian16( Len );
  31
  32         hdl = Host->HostDef->SendSETUP(Host->Ptr, Addr, EndPt, 0, NULL, &req, sizeof(req));
  33
  34         // TODO: Data toggle?
  35         // TODO: Multi-packet transfers
  36         if( Type & 0x80 )
  37         {
  38                 void    *hdl2;
  39
  40                 hdl = Host->HostDef->SendIN(Host->Ptr, Addr, EndPt, 0, NULL, Data, Len);
  41
  42                 hdl2 = Host->HostDef->SendOUT(Host->Ptr, Addr, EndPt, 0, NULL, NULL, 0);
  43                 while( Host->HostDef->IsOpComplete(Host->Ptr, hdl2) == 0 )
  44                         Time_Delay(1);
  45         }
  46         else
  47         {
  48                 void    *hdl2;
  49
  50                 if( Len > 0 )
  51                         hdl = Host->HostDef->SendOUT(Host->Ptr, Addr, EndPt, 0, NULL, Data, Len);
  52                 else
  53                         hdl = NULL;
  54
  55                 // Status phase (DataToggle=1)
  56                 hdl2 = Host->HostDef->SendIN(Host->Ptr, Addr, EndPt, 1, NULL, NULL, 0);
  57                 while( Host->HostDef->IsOpComplete(Host->Ptr, hdl2) == 0 )
  58                         Time_Delay(1);
  59         }
  60         return hdl;
  61 }
  62
  63 int USB_int_SendSetupSetAddress(tUSBHost *Host, int Address)
  64 {
  65         USB_int_Request(Host, 0, 0, 0x00, 5, Address & 0x7F, 0, 0, NULL);
  66         return 0;
  67 }
  68
  69 int USB_int_ReadDescriptor(tUSBDevice *Dev, int Endpoint, int Type, int Index, int Length, void *Dest)
  70 {
  71         const int       ciMaxPacketSize = 0x400;
  72         struct sDeviceRequest   req;
  73          int    bToggle = 0;
  74         void    *final;
  75
  76         req.ReqType = 0x80;
  77         req.Request = 6;        // GET_DESCRIPTOR
  78         req.Value = LittleEndian16( ((Type & 0xFF) << 8) | (Index & 0xFF) );
  79         req.Index = LittleEndian16( 0 );        // TODO: Language ID
  80         req.Length = LittleEndian16( Length );
  81
  82         Dev->Host->HostDef->SendSETUP(
  83                 Dev->Host->Ptr, Dev->Address, Endpoint,
  84                 0, NULL,
  85                 &req, sizeof(req)
  86                 );
  87
  88         bToggle = 1;
  89         while( Length > ciMaxPacketSize )
  90         {
  91                 Dev->Host->HostDef->SendIN(
  92                         Dev->Host->Ptr, Dev->Address, Endpoint,
  93                         bToggle, NULL,
  94                         Dest, ciMaxPacketSize
  95                         );
  96                 bToggle = !bToggle;
  97                 Length -= ciMaxPacketSize;
  98         }
  99
 100         final = Dev->Host->HostDef->SendIN(
 101                 Dev->Host->Ptr, Dev->Address, Endpoint,
 102                 bToggle, INVLPTR,
 103                 Dest, Length
 104                 );
 105
 106         while( Dev->Host->HostDef->IsOpComplete(Dev->Host->Ptr, final) == 0 )
 107                 Time_Delay(1);
 108
 109         return 0;
 110 }
 111
 112 char *USB_int_GetDeviceString(tUSBDevice *Dev, int Endpoint, int Index)
 113 {
 114         struct sDescriptor_String       str;
 115          int    src_len, new_len;
 116         char    *ret;
 117
 118         USB_int_ReadDescriptor(Dev, Endpoint, 3, Index, sizeof(str), &str);
 119 //      if(str.Length > sizeof(str)) {
 120 //              // IMPOSSIBLE!
 121 //              Log_Error("USB", "String is %i bytes, which is over prealloc size (%i)",
 122 //                      str.Length, sizeof(str)
 123 //                      );
 124 //      }
 125         src_len = (str.Length - 2) / sizeof(str.Data[0]);
 126
 127         new_len = _UTF16to8(str.Data, src_len, NULL);
 128         ret = malloc( new_len + 1 );
 129         _UTF16to8(str.Data, src_len, ret);
 130         ret[new_len] = 0;
 131         return ret;
 132 }
 133
 134 int _UTF16to8(Uint16 *Input, int InputLen, char *Dest)
 135 {
 136          int    str_len, cp_len;
 137         Uint32  saved_bits = 0;
 138         str_len = 0;
 139         for( int i = 0; i < InputLen; i ++)
 140         {
 141                 Uint32  cp;
 142                 Uint16  val = Input[i];
 143                 if( val >= 0xD800 && val <= 0xDBFF )
 144                 {
 145                         // Multibyte - Leading
 146                         if(i + 1 > InputLen) {
 147                                 cp = '?';
 148                         }
 149                         else {
 150                                 saved_bits = (val - 0xD800) << 10;
 151                                 saved_bits += 0x10000;
 152                                 continue ;
 153                         }
 154                 }
 155                 else if( val >= 0xDC00 && val <= 0xDFFF )
 156                 {
 157                         if( !saved_bits ) {
 158                                 cp = '?';
 159                         }
 160                         else {
 161                                 saved_bits |= (val - 0xDC00);
 162                                 cp = saved_bits;
 163                         }
 164                 }
 165                 else
 166                         cp = val;
 167
 168                 cp_len = WriteUTF8((Uint8*)Dest, cp);
 169                 if(Dest)
 170                         Dest += cp_len;
 171                 str_len += cp_len;
 172
 173                 saved_bits = 0;
 174         }
 175
 176         return str_len;
 177 }
 178