KernelLand/Modules/USB/MSC/main.c

   1 /*
   2  * Acess2 USB Stack Mass Storage Driver
   3  * - By John Hodge (thePowersGang)
   4  *
   5  * main.c
   6  * - Driver Core
   7  */
   8 #define DEBUG   1
   9 #define VERSION VER2(0,1)
  10 #include <acess.h>
  11 #include <modules.h>
  12 #include "common.h"
  13 #include "msc_proto.h"
  14
  15 // === PROTOTYPES ===
  16  int    MSC_Initialise(char **Arguments);
  17 void    MSC_Cleanup(void);
  18 void    MSC_DeviceConnected(tUSBInterface *Dev, void *Descriptors, size_t DescriptorsLen);
  19 void    MSC_DataIn(tUSBInterface *Dev, int EndPt, int Length, void *Data);
  20 // --- Internal Helpers
  21  int    MSC_int_CreateCBW(tMSC_CBW *Cbw, int bInput, size_t CmdLen, const void *CmdData, size_t DataLen);
  22 void    MSC_SendData(tUSBInterface *Dev, size_t CmdLen, const void *CmdData, size_t DataLen, const void *Data);
  23 void    MSC_RecvData(tUSBInterface *Dev, size_t CmdLen, const void *CmdData, size_t DataLen, void *Data);
  24
  25 // === GLOBALS ===
  26 MODULE_DEFINE(0, VERSION, USB_MSC, MSC_Initialise, MSC_Cleanup, "USB_Core", NULL);
  27 tUSBDriver      gMSC_Driver_BulkOnly = {
  28         .Name = "MSC_BulkOnly",
  29         .Match = {.Class = {0x080050, 0xFF00FF}},
  30         .Connected = MSC_DeviceConnected,
  31         .MaxEndpoints = 2,
  32         .Endpoints = {
  33                 {0x82, MSC_DataIn},
  34                 {0x02, NULL},
  35                 }
  36         };
  37 int giMSC_NextTag;
  38
  39 // === CODE ===
  40 int MSC_Initialise(char **Arguments)
  41 {
  42         USB_RegisterDriver( &gMSC_Driver_BulkOnly );
  43         return 0;
  44 }
  45
  46 void MSC_Cleanup(void)
  47 {
  48 }
  49
  50 void MSC_DeviceConnected(tUSBInterface *Dev, void *Descriptors, size_t DescriptorsLen)
  51 {
  52         tMSCInfo        *info;
  53         // TODO: Get the class code (and hence what command set is in use)
  54         // TODO: Get the maximum packet size too
  55
  56         info = malloc( sizeof(*info) );
  57         USB_SetDeviceDataPtr(Dev, info);
  58
  59         info->BlockCount = MSC_SCSI_GetSize(Dev, &info->BlockSize);
  60
  61         LVM_AddVolume(&gMSC_SCSI_VolType, "0", Dev, info->BlockSize, info->BlockCount);
  62 }
  63
  64 void MSC_DataIn(tUSBInterface *Dev, int EndPt, int Length, void *Data)
  65 {
  66         // Will this ever be needed?
  67 }
  68
  69 int MSC_int_CreateCBW(tMSC_CBW *Cbw, int bInput, size_t CmdLen, const void *CmdData, size_t DataLen)
  70 {
  71         if( CmdLen == 0 ) {
  72                 Log_Error("MSC", "Zero length commands are invalid");
  73                 return -1;
  74         }
  75
  76         if( CmdLen > 16 ) {
  77                 Log_Error("MSC", "Command data >16 bytes (%i)", CmdLen);
  78                 return -1;
  79         }
  80
  81         Cbw->dCBWSignature = LittleEndian32(0x43425355);
  82         Cbw->dCBWTag = giMSC_NextTag ++;
  83         Cbw->dCBWDataTransferLength = LittleEndian32(DataLen);
  84         Cbw->bmCBWFlags = (bInput ? 0x80 : 0x00);
  85         Cbw->bCBWLUN = 0;       // TODO: Logical Unit Number (param from proto)
  86         Cbw->bCBWLength = CmdLen;
  87         memcpy(Cbw->CBWCB, CmdData, CmdLen);
  88
  89         return 0;
  90 }
  91
  92 void MSC_SendData(tUSBInterface *Dev, size_t CmdLen, const void *CmdData, size_t DataLen, const void *Data)
  93 {
  94         tMSC_CBW        cbw;
  95         tMSC_CSW        csw;
  96         const int       endpoint_out = 2;
  97         const int       endpoint_in = 1;
  98         const int       max_packet_size = 64;
  99
 100         if( MSC_int_CreateCBW(&cbw, 0, CmdLen, CmdData, DataLen) )
 101                 return ;
 102
 103         // Send CBW
 104         USB_SendData(Dev, endpoint_out, sizeof(cbw), &cbw);
 105
 106         // Send Data
 107         for( size_t ofs = 0; ofs < DataLen; ofs += max_packet_size )
 108         {
 109                 USB_SendData(Dev, endpoint_out, MIN(max_packet_size, DataLen - ofs), Data + ofs);
 110         }
 111
 112         // Read CSW
 113         USB_RecvData(Dev, endpoint_in, sizeof(csw), &csw);
 114         // TODO: Validate CSW
 115 }
 116
 117 void MSC_RecvData(tUSBInterface *Dev, size_t CmdLen, const void *CmdData, size_t DataLen, void *Data)
 118 {
 119         tMSC_CBW        cbw;
 120         tMSC_CSW        csw;
 121         const int       endpoint_out = 2;
 122         const int       endpoint_in = 1;
 123         const int       max_packet_size = 64;
 124
 125         if( MSC_int_CreateCBW(&cbw, 1, CmdLen, CmdData, DataLen) )
 126                 return ;
 127
 128         // Send CBW
 129         USB_SendData(Dev, endpoint_out, sizeof(cbw), &cbw);
 130
 131         // Read Data
 132         for( size_t ofs = 0; ofs < DataLen; ofs += max_packet_size )
 133         {
 134                 // TODO: use async version and wait for the transaction to complete
 135                 USB_RecvData(Dev, endpoint_in, MIN(max_packet_size, DataLen - ofs), Data + ofs);
 136         }
 137
 138         // Read CSW
 139         USB_RecvData(Dev, endpoint_in, sizeof(csw), &csw);
 140         // TODO: Validate CSW
 141 }
 142