mirror of
https://github.com/felis/USB_Host_Shield_2.0.git
synced 2024-03-22 11:31:26 +01:00
414 lines
9.8 KiB
C++
414 lines
9.8 KiB
C++
/* Copyright (C) 2011 Circuits At Home, LTD. All rights reserved.
|
|
|
|
This software may be distributed and modified under the terms of the GNU
|
|
General Public License version 2 (GPL2) as published by the Free Software
|
|
Foundation and appearing in the file GPL2.TXT included in the packaging of
|
|
this file. Please note that GPL2 Section 2[b] requires that all works based
|
|
on this software must also be made publicly available under the terms of
|
|
the GPL2 ("Copyleft").
|
|
|
|
Contact information
|
|
-------------------
|
|
|
|
Circuits At Home, LTD
|
|
Web : http://www.circuitsathome.com
|
|
e-mail : support@circuitsathome.com
|
|
*/
|
|
#include "usbhub.h"
|
|
|
|
bool USBHub::bResetInitiated = false;
|
|
|
|
USBHub::USBHub(USB *p) :
|
|
pUsb(p),
|
|
bAddress(0),
|
|
bNbrPorts(0),
|
|
bInitState(0),
|
|
qNextPollTime(0),
|
|
bPollEnable(false)
|
|
{
|
|
epInfo[0].epAddr = 0;
|
|
epInfo[0].maxPktSize = 8;
|
|
epInfo[0].epAttribs = 0;
|
|
epInfo[0].bmNakPower = USB_NAK_MAX_POWER;
|
|
|
|
epInfo[1].epAddr = 1;
|
|
epInfo[1].maxPktSize = 1;
|
|
epInfo[1].epAttribs = 0;
|
|
|
|
if (pUsb)
|
|
pUsb->RegisterDeviceClass(this);
|
|
}
|
|
|
|
uint8_t USBHub::Init(uint8_t parent, uint8_t port, bool lowspeed)
|
|
{
|
|
uint8_t buf[32];
|
|
uint8_t rcode;
|
|
UsbDevice *p = NULL;
|
|
EpInfo *oldep_ptr = NULL;
|
|
uint8_t len = 0;
|
|
uint16_t cd_len = 0;
|
|
|
|
//USBTRACE("\r\nHub Init Start");
|
|
|
|
AddressPool &addrPool = pUsb->GetAddressPool();
|
|
|
|
switch (bInitState)
|
|
{
|
|
case 0:
|
|
if (bAddress)
|
|
return USB_ERROR_CLASS_INSTANCE_ALREADY_IN_USE;
|
|
|
|
// Get pointer to pseudo device with address 0 assigned
|
|
p = addrPool.GetUsbDevicePtr(0);
|
|
|
|
if (!p)
|
|
return USB_ERROR_ADDRESS_NOT_FOUND_IN_POOL;
|
|
|
|
if (!p->epinfo)
|
|
return USB_ERROR_EPINFO_IS_NULL;
|
|
|
|
// Save old pointer to EP_RECORD of address 0
|
|
oldep_ptr = p->epinfo;
|
|
|
|
// Temporary assign new pointer to epInfo to p->epinfo in order to avoid toggle inconsistence
|
|
p->epinfo = epInfo;
|
|
|
|
p->lowspeed = lowspeed;
|
|
|
|
// Get device descriptor
|
|
rcode = pUsb->getDevDescr( 0, 0, 8, (uint8_t*)buf );
|
|
|
|
p->lowspeed = false;
|
|
|
|
if (!rcode)
|
|
len = (buf[0] > 32) ? 32 : buf[0];
|
|
|
|
if( rcode )
|
|
{
|
|
// Restore p->epinfo
|
|
p->epinfo = oldep_ptr;
|
|
return rcode;
|
|
}
|
|
|
|
// Extract device class from device descriptor
|
|
// If device class is not a hub return
|
|
if (((USB_DEVICE_DESCRIPTOR*)buf)->bDeviceClass != 0x09)
|
|
return USB_DEV_CONFIG_ERROR_DEVICE_NOT_SUPPORTED;
|
|
|
|
// Allocate new address according to device class
|
|
bAddress = addrPool.AllocAddress(parent, (((USB_DEVICE_DESCRIPTOR*)buf)->bDeviceClass == 0x09) ? true : false, port);
|
|
|
|
if (!bAddress)
|
|
return USB_ERROR_OUT_OF_ADDRESS_SPACE_IN_POOL;
|
|
|
|
// Extract Max Packet Size from the device descriptor
|
|
epInfo[0].maxPktSize = ((USB_DEVICE_DESCRIPTOR*)buf)->bMaxPacketSize0;
|
|
|
|
// Assign new address to the device
|
|
rcode = pUsb->setAddr( 0, 0, bAddress );
|
|
|
|
if (rcode)
|
|
{
|
|
// Restore p->epinfo
|
|
p->epinfo = oldep_ptr;
|
|
addrPool.FreeAddress(bAddress);
|
|
bAddress = 0;
|
|
return rcode;
|
|
}
|
|
|
|
//USBTRACE2("\r\nHub address: ", bAddress );
|
|
|
|
// Restore p->epinfo
|
|
p->epinfo = oldep_ptr;
|
|
|
|
if (len)
|
|
rcode = pUsb->getDevDescr( bAddress, 0, len, (uint8_t*)buf );
|
|
|
|
if(rcode)
|
|
goto FailGetDevDescr;
|
|
|
|
// Assign epInfo to epinfo pointer
|
|
rcode = pUsb->setEpInfoEntry(bAddress, 2, epInfo);
|
|
|
|
if (rcode)
|
|
goto FailSetDevTblEntry;
|
|
|
|
bInitState = 1;
|
|
|
|
case 1:
|
|
// Get hub descriptor
|
|
rcode = GetHubDescriptor(0, 8, buf);
|
|
|
|
if (rcode)
|
|
goto FailGetHubDescr;
|
|
|
|
// Save number of ports for future use
|
|
bNbrPorts = ((HubDescriptor*)buf)->bNbrPorts;
|
|
|
|
bInitState = 2;
|
|
|
|
case 2:
|
|
// Read configuration Descriptor in Order To Obtain Proper Configuration Value
|
|
rcode = pUsb->getConfDescr(bAddress, 0, 8, 0, buf);
|
|
|
|
if (!rcode)
|
|
{
|
|
cd_len = ((USB_CONFIGURATION_DESCRIPTOR*)buf)->wTotalLength;
|
|
rcode = pUsb->getConfDescr(bAddress, 0, cd_len, 0, buf);
|
|
}
|
|
if (rcode)
|
|
goto FailGetConfDescr;
|
|
|
|
// The following code is of no practical use in real life applications.
|
|
// It only intended for the usb protocol sniffer to properly parse hub-class requests.
|
|
{
|
|
uint8_t buf2[24];
|
|
|
|
rcode = pUsb->getConfDescr(bAddress, 0, buf[0], 0, buf2);
|
|
|
|
if (rcode)
|
|
goto FailGetConfDescr;
|
|
}
|
|
|
|
// Set Configuration Value
|
|
rcode = pUsb->setConf(bAddress, 0, buf[5]);
|
|
|
|
if (rcode)
|
|
goto FailSetConfDescr;
|
|
|
|
bInitState = 3;
|
|
|
|
case 3:
|
|
// Power on all ports
|
|
for (uint8_t j=1; j<=bNbrPorts; j++)
|
|
SetPortFeature(HUB_FEATURE_PORT_POWER, j, 0); //HubPortPowerOn(j);
|
|
|
|
pUsb->SetHubPreMask();
|
|
bPollEnable = true;
|
|
bInitState = 0;
|
|
}
|
|
bInitState = 0;
|
|
return 0;
|
|
|
|
FailGetDevDescr:
|
|
goto Fail;
|
|
|
|
FailSetDevTblEntry:
|
|
goto Fail;
|
|
|
|
FailGetHubDescr:
|
|
goto Fail;
|
|
|
|
FailGetConfDescr:
|
|
goto Fail;
|
|
|
|
FailSetConfDescr:
|
|
goto Fail;
|
|
|
|
FailGetPortStatus:
|
|
goto Fail;
|
|
|
|
Fail:
|
|
return rcode;
|
|
}
|
|
|
|
uint8_t USBHub::Release()
|
|
{
|
|
pUsb->GetAddressPool().FreeAddress(bAddress);
|
|
|
|
if (bAddress == 0x41)
|
|
pUsb->SetHubPreMask();
|
|
|
|
bAddress = 0;
|
|
bNbrPorts = 0;
|
|
qNextPollTime = 0;
|
|
bPollEnable = false;
|
|
return 0;
|
|
}
|
|
|
|
uint8_t USBHub::Poll()
|
|
{
|
|
uint8_t rcode = 0;
|
|
|
|
if (!bPollEnable)
|
|
return 0;
|
|
|
|
if (qNextPollTime <= millis())
|
|
{
|
|
rcode = CheckHubStatus();
|
|
qNextPollTime = millis() + 100;
|
|
}
|
|
return rcode;
|
|
}
|
|
|
|
uint8_t USBHub::CheckHubStatus()
|
|
{
|
|
uint8_t rcode;
|
|
uint8_t buf[8];
|
|
uint16_t read = 1;
|
|
|
|
rcode = pUsb->inTransfer(bAddress, 1, &read, buf);
|
|
|
|
if (rcode)
|
|
return rcode;
|
|
|
|
if (buf[0] & 0x01) // Hub Status Change
|
|
{
|
|
//pUsb->PrintHubStatus(addr);
|
|
//rcode = GetHubStatus(1, 0, 1, 4, buf);
|
|
//if (rcode)
|
|
//{
|
|
// Serial.print("GetHubStatus Error");
|
|
// Serial.println(rcode, HEX);
|
|
// return rcode;
|
|
//}
|
|
}
|
|
for (uint8_t port=1,mask=0x02; port<8; mask<<=1, port++)
|
|
{
|
|
if (buf[0] & mask)
|
|
{
|
|
HubEvent evt;
|
|
evt.bmEvent = 0;
|
|
|
|
rcode = GetPortStatus(port, 4, evt.evtBuff);
|
|
|
|
if (rcode)
|
|
continue;
|
|
|
|
rcode = PortStatusChange(port, evt);
|
|
|
|
if (rcode == HUB_ERROR_PORT_HAS_BEEN_RESET)
|
|
return 0;
|
|
|
|
if (rcode)
|
|
return rcode;
|
|
}
|
|
} // for
|
|
|
|
for (uint8_t port=1; port<=bNbrPorts; port++)
|
|
{
|
|
HubEvent evt;
|
|
evt.bmEvent = 0;
|
|
|
|
rcode = GetPortStatus(port, 4, evt.evtBuff);
|
|
|
|
if (rcode)
|
|
continue;
|
|
|
|
if ((evt.bmStatus & bmHUB_PORT_STATE_CHECK_DISABLED) != bmHUB_PORT_STATE_DISABLED)
|
|
continue;
|
|
|
|
// Emulate connection event for the port
|
|
evt.bmChange |= bmHUB_PORT_STATUS_C_PORT_CONNECTION;
|
|
|
|
rcode = PortStatusChange(port, evt);
|
|
|
|
if (rcode == HUB_ERROR_PORT_HAS_BEEN_RESET)
|
|
return 0;
|
|
|
|
if (rcode)
|
|
return rcode;
|
|
} // for
|
|
return 0;
|
|
}
|
|
|
|
uint8_t USBHub::PortStatusChange(uint8_t port, HubEvent &evt)
|
|
{
|
|
switch (evt.bmEvent)
|
|
{
|
|
// Device connected event
|
|
case bmHUB_PORT_EVENT_CONNECT:
|
|
case bmHUB_PORT_EVENT_LS_CONNECT:
|
|
if (bResetInitiated)
|
|
return 0;
|
|
|
|
ClearPortFeature(HUB_FEATURE_C_PORT_ENABLE, port, 0);
|
|
ClearPortFeature(HUB_FEATURE_C_PORT_CONNECTION, port, 0);
|
|
SetPortFeature(HUB_FEATURE_PORT_RESET, port, 0);
|
|
bResetInitiated = true;
|
|
return HUB_ERROR_PORT_HAS_BEEN_RESET;
|
|
|
|
// Device disconnected event
|
|
case bmHUB_PORT_EVENT_DISCONNECT:
|
|
ClearPortFeature(HUB_FEATURE_C_PORT_ENABLE, port, 0);
|
|
ClearPortFeature(HUB_FEATURE_C_PORT_CONNECTION, port, 0);
|
|
bResetInitiated = false;
|
|
|
|
UsbDeviceAddress a;
|
|
a.bmHub = 0;
|
|
a.bmParent = bAddress;
|
|
a.bmAddress = port;
|
|
pUsb->ReleaseDevice(a.devAddress);
|
|
return 0;
|
|
|
|
// Reset complete event
|
|
case bmHUB_PORT_EVENT_RESET_COMPLETE:
|
|
case bmHUB_PORT_EVENT_LS_RESET_COMPLETE:
|
|
ClearPortFeature(HUB_FEATURE_C_PORT_RESET, port, 0);
|
|
ClearPortFeature(HUB_FEATURE_C_PORT_CONNECTION, port, 0);
|
|
|
|
delay(20);
|
|
|
|
a.devAddress = bAddress;
|
|
|
|
pUsb->Configuring(a.bmAddress, port, (evt.bmStatus & bmHUB_PORT_STATUS_PORT_LOW_SPEED) );
|
|
bResetInitiated = false;
|
|
break;
|
|
|
|
} // switch (evt.bmEvent)
|
|
return 0;
|
|
}
|
|
|
|
void PrintHubPortStatus(USBHub *hubptr, uint8_t addr, uint8_t port, bool print_changes)
|
|
{
|
|
uint8_t rcode = 0;
|
|
HubEvent evt;
|
|
|
|
rcode = hubptr->GetPortStatus(port, 4, evt.evtBuff);
|
|
|
|
if (rcode)
|
|
{
|
|
Serial.println("ERROR!!!");
|
|
return;
|
|
}
|
|
Serial.print("\r\nPort ");
|
|
Serial.println(port, DEC);
|
|
|
|
Serial.println("Status");
|
|
Serial.print("CONNECTION:\t");
|
|
Serial.println((evt.bmStatus & bmHUB_PORT_STATUS_PORT_CONNECTION) > 0, DEC);
|
|
Serial.print("ENABLE:\t\t");
|
|
Serial.println((evt.bmStatus & bmHUB_PORT_STATUS_PORT_ENABLE) > 0, DEC);
|
|
Serial.print("SUSPEND:\t");
|
|
Serial.println((evt.bmStatus & bmHUB_PORT_STATUS_PORT_SUSPEND) > 0, DEC);
|
|
Serial.print("OVER_CURRENT:\t");
|
|
Serial.println((evt.bmStatus & bmHUB_PORT_STATUS_PORT_OVER_CURRENT) > 0, DEC);
|
|
Serial.print("RESET:\t\t");
|
|
Serial.println((evt.bmStatus & bmHUB_PORT_STATUS_PORT_RESET) > 0, DEC);
|
|
Serial.print("POWER:\t\t");
|
|
Serial.println((evt.bmStatus & bmHUB_PORT_STATUS_PORT_POWER) > 0, DEC);
|
|
Serial.print("LOW_SPEED:\t");
|
|
Serial.println((evt.bmStatus & bmHUB_PORT_STATUS_PORT_LOW_SPEED) > 0, DEC);
|
|
Serial.print("HIGH_SPEED:\t");
|
|
Serial.println((evt.bmStatus & bmHUB_PORT_STATUS_PORT_HIGH_SPEED) > 0, DEC);
|
|
Serial.print("TEST:\t\t");
|
|
Serial.println((evt.bmStatus & bmHUB_PORT_STATUS_PORT_TEST) > 0, DEC);
|
|
Serial.print("INDICATOR:\t");
|
|
Serial.println((evt.bmStatus & bmHUB_PORT_STATUS_PORT_INDICATOR) > 0, DEC);
|
|
|
|
if (!print_changes)
|
|
return;
|
|
|
|
Serial.println("\nChange");
|
|
Serial.print("CONNECTION:\t");
|
|
Serial.println((evt.bmChange & bmHUB_PORT_STATUS_C_PORT_CONNECTION) > 0, DEC);
|
|
Serial.print("ENABLE:\t\t");
|
|
Serial.println((evt.bmChange & bmHUB_PORT_STATUS_C_PORT_ENABLE) > 0, DEC);
|
|
Serial.print("SUSPEND:\t");
|
|
Serial.println((evt.bmChange & bmHUB_PORT_STATUS_C_PORT_SUSPEND) > 0, DEC);
|
|
Serial.print("OVER_CURRENT:\t");
|
|
Serial.println((evt.bmChange & bmHUB_PORT_STATUS_C_PORT_OVER_CURRENT) > 0, DEC);
|
|
Serial.print("RESET:\t\t");
|
|
Serial.println((evt.bmChange & bmHUB_PORT_STATUS_C_PORT_RESET) > 0, DEC);
|
|
}
|