usbp_cyusb.cpp

Go to the documentation of this file.

/* -*- c++ -*- */
#include <stdio.h>
#include <string>
#include <cassert>
#include "usbp_cyusb.h"
#include "upl_err.h"

using namespace std;

int CUsbpCyUSB::deviceInfo()
{
  int err = UPL_OK;
  //String s;
  
  if(USBDevice == NULL){
    err = UPL_USB_ERR;
    printf("OPEN First!\n");
  }
  else{
        printf("USBDevice ConfigCount\n", USBDevice->ConfigCount()); 
    for(int c=0; c<USBDevice->ConfigCount(); c++){
      CCyUSBConfig cfg = USBDevice->GetUSBConfig(c);
      
      // \todo Write to the Status report, not directly print.
      printf("bLength : 0x%x\n", cfg.bLength);
      printf("bDescriptorType: %d (0x%x)\n", cfg.wTotalLength,cfg.wTotalLength);
      printf("bLength: 0x%x\n",cfg.bLength); 
      printf("bDescriptorType: %d\n",cfg.bDescriptorType);   
      printf("wTotalLength: %d (0x%x)\n",cfg.wTotalLength,cfg.wTotalLength);   
      printf("bNumInterfaces: %d\n",cfg.bNumInterfaces);   
      printf("bConfigurationValue: %d\n",cfg.bConfigurationValue);   
      printf("iConfiguration: %d\n",cfg.iConfiguration);   
      printf("bmAttributes: 0x%x\n",cfg.bmAttributes); 
      printf("MaxPower: %d\n",cfg.MaxPower); 
      printf("**********************************\n");
      
      for (int i=0; i<cfg.AltInterfaces; i++) {
        CCyUSBInterface *ifc = cfg.Interfaces[i];
        //printf("Interface Descriptor:" + String(i+1));
        printf("--------------------------------\n");
        printf("bLength: 0x%x\n",ifc->bLength); 
        printf("bDescriptorType: %d\n",ifc->bDescriptorType); 
        printf("bInterfaceNumber: %d\n",ifc->bInterfaceNumber);   
        printf("bAlternateSetting: %d\n",ifc->bAlternateSetting); 
        printf("bNumEndpoints: %d\n",ifc->bNumEndpoints); 
        printf("bInterfaceClass: %d\n",ifc->bInterfaceClass); 
        
        for (int e=0; e<ifc->bNumEndpoints; e++) {
          CCyUSBEndPoint *ept = ifc->EndPoints[e+1];
          //printf("EndPoint Descriptor: " + String(e+1));
          printf("--------------------------------\n");
          printf("bLength: 0x%x\n",ept->DscLen); 
          printf("bDescriptorType: %d\n",ept->DscType); 
          printf("bEndpointAddress: 0x%x\n",ept->Address); 
          printf("bmAttributes: 0x%x\n",ept->Attributes); 
          printf("wMaxPacketSize: %d\n",ept->MaxPktSize); 
          printf("bInterval: %d\n",ept->Interval); 
          printf("**********************************\n");
        }
      }
    }
  }
  
  return err;
}


int CUsbpCyUSB::deviceInfo(int vid, int pid)
{
  int err = UPL_OK;
  
  return err;
}


int CUsbpCyUSB::deviceOpen(int vid, int pid)
{
  int err = UPL_OK;
  
  // Don't really know what m_hWnd is??
  USBDevice = new CCyUSBDevice(); // m_hWnd, handle to the main window
  
  int devices = USBDevice->DeviceCount();
  
  printf("%d Devices Present\n", devices);
  
  int myDevice = -1;
  int vID, pID;
  
  for(int i=0; i<devices; i++){
    USBDevice->Open(i); // Automatically calls Close() ??
    vID = USBDevice->VendorID;
    pID = USBDevice->ProductID;
    printf("USBDevice[%d] vid %04X pid %04X\n", i, vID, pID);
    
    if(vID == vid && pID == pid){
      printf("Found Device!!\n");
      myDevice = i;

          assignEpt();

          break;
    }
  }
  
  if(myDevice == -1){
    printf("No Devices Found\n");
    USBDevice->Open(myDevice);
    err = UPL_ERR;
  }
  
  return err;
}


int CUsbpCyUSB::deviceStatus()
{
  int err = UPL_OK;
  PCHAR status = NULL;
  LONG stat = NULL;
  
  USBDevice->UsbdStatusString(stat,status);
  
  printf("%s (%d)\n", status, stat);
  
  return err;
}


int CUsbpCyUSB::deviceCheck()
{
  int err = UPL_OK;
  
  return err;
}


int CUsbpCyUSB::deviceClose(int vid, int pid)
{
  int err = UPL_OK;
  
  if(USBDevice){
    delete USBDevice;
    USBDevice = NULL;
  }

  BulkOutEpt2 = NULL;
  BulkInEpt6  = NULL;
  BulkOutEpt4 = NULL;
  BulkInEpt8  = NULL;

  return err;
}


int CUsbpCyUSB::controlWrite(
                            byte reqCode,
                            unsigned short value,
                            unsigned short index,
                            byte *b, int len, int timeout)
{
  
  int err = UPL_OK;
  int xferOk = 1;
  LONG lenr = len;
  
  CCyControlEndPoint *ept = USBDevice->ControlEndPt;
  
  if(ept){
    ept->Target    = TGT_DEVICE;    // ?? Examples Usually 
    ept->ReqType   = REQ_VENDOR;    // For these purposes control always vendor
    ept->Direction = DIR_TO_DEVICE; //
    ept->ReqCode   = reqCode;       // 
    ept->Value     = value;         //
    ept->Index     = index;         //
    
    ept->TimeOut = timeout*1000; // 4 seconds, more than enough time.
    xferOk = ept->XferData(b, lenr);

        if(!xferOk && (reqCode != 0x02)) {
                printf("ControlWrite USB Error 0x%x\n", xferOk);
                err = UPL_ERR;
        }
  }
  else{
    err = UPL_USB_ERR;
  }
  
  if((len != lenr) && (reqCode != 0x02)){
    err = UPL_ERR;
    printf("Control Write bad len %d %d\n", len, lenr);
  }
  
  return err;
}


int CUsbpCyUSB::bulkWrite(int ep, int size, byte *b)
{
  bool xferOk;
  int err = UPL_OK;
  CCyBulkEndPoint *ept;
  LONG lenr = size;

  if(ep == 2)
    ept = BulkOutEpt2; //(CCyBulkEndPoint *)USBDevice->EndPoints[0];
  else if(ep == 4)
    ept = BulkOutEpt4; //(CCyBulkEndPoint *)USBDevice->EndPoints[1];
  else
    ept = 0;
  
  if(ept){ 
    xferOk = ept->XferData(b, lenr);
    
    if(!xferOk){
      fprintf(stderr, "-- XferData(%x, %d) FAILED == %d\n",(unsigned int)b,lenr,xferOk);
      deviceInfo();
      err = UPL_ERR;
    }
  }
  else{
    fprintf(stderr, "-- Not a Valid Endpoint!");
    err = UPL_ERR;
  }

  return err;
}

int CUsbpCyUSB::bulkRead(int ep, int size, byte *b)
{
  bool xferOk;
  int err = UPL_OK;
  CCyBulkEndPoint *ept;
  LONG lenr = size;

  if(ep == 6)
    ept = BulkInEpt6; //(CCyBulkEndPoint *)USBDevice->EndPoints[0];
  else if(ep == 8)
    ept = BulkInEpt8; //(CCyBulkEndPoint *)USBDevice->EndPoints[1];
  else
    ept = 0;
  
  if(ept){ 
    xferOk = ept->XferData(b, lenr);
    
    if(!xferOk){
      fprintf(stderr, "-- XferData(%x, %d) FAILED == %d\n",(unsigned int)b,lenr,xferOk);
      deviceInfo();
      err = UPL_ERR;
    }
  }
  else{
    fprintf(stderr, "-- Not a Valid Endpoint!");
    err = UPL_ERR;
  }

  return err;
}

int CUsbpCyUSB::bulkWriteRead(int ep_out, int ep_in, int size, byte *b)
{
  int err = UPL_OK;
  
  return err;
}


int CUsbpCyUSB::assignEpt()
{
  
  int eptCount = USBDevice->EndPointCount();
  printf("Number of Endpoints present %d\n", eptCount);
  for (int i=1; i<eptCount; i++) {
    byte addr = USBDevice->EndPoints[i]->Address & 0x7F;
    bool bIn =   ((USBDevice->EndPoints[i]->Address & 0x80) == 0x80);
    bool bBulk = (USBDevice->EndPoints[i]->Attributes == 2);
    
    printf("Assign Endpoint 0x%x", addr);
    if(bIn) printf(" Bulk In"); else printf(" Bulk Out");
    switch(addr){
    case 0x02: BulkOutEpt2 = (CCyBulkEndPoint *) USBDevice->EndPoints[i];  printf(" to BulkOutEpt2\n"); break;
    case 0x06: BulkInEpt6  = (CCyBulkEndPoint *) USBDevice->EndPoints[i];  printf(" to BulkInEpt6\n"); break;
    case 0x04: BulkOutEpt4 = (CCyBulkEndPoint *) USBDevice->EndPoints[i];  printf(" to BulkOutEpt4\n"); break;
    case 0x08: BulkInEpt8  = (CCyBulkEndPoint *) USBDevice->EndPoints[i];  printf(" to BulkInEpt8\n"); break;
    default: printf(" to no EPT\n");
    }
  }
  
  return UPL_OK;
}

---