USB_Host_Shield_2.0/adk.cpp

340 lines
9.7 KiB
C++
Raw Normal View History

2011-07-07 04:33:52 +02:00
/* 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
*/
2011-07-01 06:31:46 +02:00
/* Google ADK interface */
#include "adk.h"
const uint8_t ADK::epDataInIndex = 1;
const uint8_t ADK::epDataOutIndex = 2;
ADK::ADK(USB *p, const char* manufacturer,
const char* model,
const char* description,
const char* version,
const char* uri,
const char* serial) :
2011-07-02 20:43:38 +02:00
pUsb(p), //pointer to USB class instance - mandatory
bAddress(0), //device address - mandatory
bNumEP(1), //if config descriptor needs to be parsed
2011-07-07 03:48:43 +02:00
ready(false),
2011-07-02 20:43:38 +02:00
2011-07-02 04:25:50 +02:00
/* ADK ID Strings */
2011-07-02 20:43:38 +02:00
2011-07-01 06:31:46 +02:00
manufacturer(manufacturer),
model(model),
description(description),
version(version),
uri(uri),
2011-07-02 20:43:38 +02:00
serial(serial)
2011-07-01 06:31:46 +02:00
{
2011-07-02 20:43:38 +02:00
// initialize endpoint data structures
for(uint8_t i=0; i<ADK_MAX_ENDPOINTS; i++) {
2011-07-01 06:31:46 +02:00
epInfo[i].epAddr = 0;
epInfo[i].maxPktSize = (i) ? 0 : 8;
2011-07-02 20:43:38 +02:00
epInfo[i].epAttribs = ( 0xfc & ( USB_NAK_MAX_POWER<<2 ));
}//for(uint8_t i=0; i<ADK_MAX_ENDPOINTS; i++...
2011-07-07 03:48:43 +02:00
//set bulk-IN EP naklimit to 1
epInfo[epDataInIndex].epAttribs = ( 0xfc & ( USB_NAK_NOWAIT<<2 ));
2011-07-02 20:43:38 +02:00
// register in USB subsystem
2011-07-02 04:25:50 +02:00
if (pUsb) {
pUsb->RegisterDeviceClass(this); //set devConfig[] entry
2011-07-01 06:31:46 +02:00
}
}
2011-07-02 04:25:50 +02:00
2011-07-02 08:45:36 +02:00
/* Connection initialization of an Android phone */
2011-07-01 06:31:46 +02:00
uint8_t ADK::Init(uint8_t parent, uint8_t port, bool lowspeed)
{
2011-07-02 20:43:38 +02:00
uint8_t buf[sizeof(USB_DEVICE_DESCRIPTOR)];
2011-07-01 06:31:46 +02:00
uint8_t rcode;
UsbDevice *p = NULL;
EpInfo *oldep_ptr = NULL;
uint8_t num_of_conf; // number of configurations
// get memory address of USB device address pool
AddressPool &addrPool = pUsb->GetAddressPool();
USBTRACE("\r\nADK Init");
// check if address has already been assigned to an instance
2011-07-02 04:25:50 +02:00
if (bAddress) {
USBTRACE("\r\nAddress in use");
2011-07-01 06:31:46 +02:00
return USB_ERROR_CLASS_INSTANCE_ALREADY_IN_USE;
2011-07-02 04:25:50 +02:00
}
2011-07-01 06:31:46 +02:00
// Get pointer to pseudo device with address 0 assigned
p = addrPool.GetUsbDevicePtr(0);
2011-07-02 04:25:50 +02:00
if (!p) {
USBTRACE("\r\nAddress not found");
2011-07-01 06:31:46 +02:00
return USB_ERROR_ADDRESS_NOT_FOUND_IN_POOL;
2011-07-02 04:25:50 +02:00
}
2011-07-01 06:31:46 +02:00
if (!p->epinfo) {
USBTRACE("epinfo is null\r\n");
return USB_ERROR_EPINFO_IS_NULL;
}
2011-07-02 04:25:50 +02:00
2011-07-01 06:31:46 +02:00
// 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
2011-07-02 20:43:38 +02:00
rcode = pUsb->getDevDescr( 0, 0, sizeof(USB_DEVICE_DESCRIPTOR), (uint8_t*)buf );
2011-07-02 04:25:50 +02:00
2011-07-01 06:31:46 +02:00
// Restore p->epinfo
p->epinfo = oldep_ptr;
if( rcode ){
goto FailGetDevDescr;
}
2011-07-02 04:25:50 +02:00
2011-07-02 20:43:38 +02:00
// Allocate new address according to device class
bAddress = addrPool.AllocAddress(parent, false, port);
2011-07-02 04:25:50 +02:00
2011-07-02 20:43:38 +02:00
// Extract Max Packet Size from device descriptor
epInfo[0].maxPktSize = (uint8_t)((USB_DEVICE_DESCRIPTOR*)buf)->bMaxPacketSize0;
2011-07-02 04:25:50 +02:00
2011-07-02 20:43:38 +02:00
// Assign new address to the device
rcode = pUsb->setAddr( 0, 0, bAddress );
if (rcode) {
p->lowspeed = false;
addrPool.FreeAddress(bAddress);
bAddress = 0;
2011-07-07 03:48:43 +02:00
//USBTRACE2("setAddr:",rcode);
2011-07-02 20:43:38 +02:00
return rcode;
}//if (rcode...
2011-07-02 04:25:50 +02:00
2011-07-07 03:48:43 +02:00
//USBTRACE2("\r\nAddr:", bAddress);
2011-07-02 04:25:50 +02:00
2011-07-02 20:43:38 +02:00
p->lowspeed = false;
2011-07-02 04:25:50 +02:00
2011-07-02 20:43:38 +02:00
//get pointer to assigned address record
p = addrPool.GetUsbDevicePtr(bAddress);
if (!p) {
return USB_ERROR_ADDRESS_NOT_FOUND_IN_POOL;
}
2011-07-02 04:25:50 +02:00
2011-07-02 20:43:38 +02:00
p->lowspeed = lowspeed;
2011-07-02 04:25:50 +02:00
2011-07-07 03:48:43 +02:00
// Assign epInfo to epinfo pointer - only EP0 is known
2011-07-02 20:43:38 +02:00
rcode = pUsb->setEpInfoEntry(bAddress, 1, epInfo);
if (rcode) {
goto FailSetDevTblEntry;
}
2011-07-02 04:25:50 +02:00
2011-07-02 20:43:38 +02:00
//check if ADK device is already in accessory mode; if yes, configure and exit
2011-07-02 08:45:36 +02:00
if(((USB_DEVICE_DESCRIPTOR*)buf)->idVendor == ADK_VID &&
(((USB_DEVICE_DESCRIPTOR*)buf)->idProduct == ADK_PID || ((USB_DEVICE_DESCRIPTOR*)buf)->idProduct == ADB_PID)) {
USBTRACE("\r\nAcc.mode device detected");
2011-07-02 20:43:38 +02:00
/* go through configurations, find first bulk-IN, bulk-OUT EP, fill epInfo and quit */
2011-07-02 08:45:36 +02:00
num_of_conf = ((USB_DEVICE_DESCRIPTOR*)buf)->bNumConfigurations;
2011-07-02 04:25:50 +02:00
2011-07-07 03:48:43 +02:00
//USBTRACE2("\r\nNC:",num_of_conf);
2011-07-02 04:25:50 +02:00
2011-07-02 08:45:36 +02:00
for (uint8_t i=0; i<num_of_conf; i++) {
ConfigDescParser<0, 0, 0, 0> confDescrParser(this);
2011-07-02 20:43:38 +02:00
rcode = pUsb->getConfDescr(bAddress, 0, i, &confDescrParser);
if( rcode ) {
goto FailGetConfDescr;
}
2011-07-02 08:45:36 +02:00
if( bNumEP > 2 ) {
break;
}
} // for (uint8_t i=0; i<num_of_conf; i++...
2011-07-07 03:48:43 +02:00
if( bNumEP == 3 ) {
// Assign epInfo to epinfo pointer - this time all 3 endpoins
rcode = pUsb->setEpInfoEntry(bAddress, 3, epInfo);
if (rcode) {
goto FailSetDevTblEntry;
}
}
2011-07-01 06:31:46 +02:00
2011-07-02 04:25:50 +02:00
// Set Configuration Value
2011-07-01 06:31:46 +02:00
rcode = pUsb->setConf(bAddress, 0, bConfNum);
2011-07-02 08:45:36 +02:00
if( rcode ){
goto FailSetConf;
}
/* print endpoint structure */
2011-07-07 03:48:43 +02:00
// USBTRACE("\r\nEndpoint Structure:");
// USBTRACE("\r\nEP0:");
// USBTRACE2("\r\nAddr: ", epInfo[0].epAddr );
// USBTRACE2("\r\nMax.pkt.size: ", epInfo[0].maxPktSize );
// USBTRACE2("\r\nAttr: ", epInfo[0].epAttribs );
// USBTRACE("\r\nEpout:");
// USBTRACE2("\r\nAddr: ", epInfo[epDataOutIndex].epAddr );
// USBTRACE2("\r\nMax.pkt.size: ", epInfo[epDataOutIndex].maxPktSize );
// USBTRACE2("\r\nAttr: ", epInfo[epDataOutIndex].epAttribs );
// USBTRACE("\r\nEpin:");
// USBTRACE2("\r\nAddr: ", epInfo[epDataInIndex].epAddr );
// USBTRACE2("\r\nMax.pkt.size: ", epInfo[epDataInIndex].maxPktSize );
// USBTRACE2("\r\nAttr: ", epInfo[epDataInIndex].epAttribs );
2011-07-02 08:45:36 +02:00
USBTRACE("\r\nConfiguration successful");
2011-07-07 03:48:43 +02:00
ready = true;
2011-07-01 06:31:46 +02:00
return 0; //successful configuration
}//if( buf->idVendor == ADK_VID...
//probe device - get accessory protocol revision
{
uint16_t adkproto = -1;
rcode = getProto((uint8_t*)&adkproto );
if( rcode ){
goto FailGetProto; //init fails
}
USBTRACE2("\r\nADK protocol rev. ", adkproto );
}
2011-07-02 04:25:50 +02:00
//sending ID strings
sendStr( ACCESSORY_STRING_MANUFACTURER, manufacturer);
sendStr( ACCESSORY_STRING_MODEL, model);
sendStr( ACCESSORY_STRING_DESCRIPTION, description);
sendStr( ACCESSORY_STRING_VERSION, version);
sendStr( ACCESSORY_STRING_URI, uri);
sendStr( ACCESSORY_STRING_SERIAL, serial);
//switch to accessory mode
2011-07-02 20:43:38 +02:00
//the Android phone will reset
2011-07-01 06:31:46 +02:00
rcode = switchAcc();
if( rcode ) {
goto FailSwAcc; //init fails
}
rcode = -1;
goto SwAttempt; //switch to accessory mode attempted
2011-07-02 20:43:38 +02:00
/* diagnostic messages */
2011-07-01 06:31:46 +02:00
FailGetDevDescr:
USBTRACE("\r\ngetDevDescr:");
goto Fail;
2011-07-02 04:25:50 +02:00
FailSetDevTblEntry:
USBTRACE("\r\nsetDevTblEn:");
goto Fail;
2011-07-01 06:31:46 +02:00
FailGetProto:
USBTRACE("\r\ngetProto:");
goto Fail;
FailSwAcc:
USBTRACE("\r\nswAcc:");
goto Fail;
SwAttempt:
USBTRACE("\r\nAccessory mode switch attempt");
goto Fail;
2011-07-02 20:43:38 +02:00
FailGetConfDescr:
2011-07-01 06:31:46 +02:00
// USBTRACE("getConf:");
2011-07-02 20:43:38 +02:00
goto Fail;
2011-07-01 06:31:46 +02:00
//
2011-07-02 08:45:36 +02:00
FailSetConf:
2011-07-02 04:25:50 +02:00
// USBTRACE("setConf:");
2011-07-02 08:45:36 +02:00
goto Fail;
2011-07-01 06:31:46 +02:00
//
//FailOnInit:
// USBTRACE("OnInit:");
// goto Fail;
//
Fail:
2011-07-07 03:48:43 +02:00
//USBTRACE2("\r\nADK Init Failed, error code: ", rcode);
Release();
2011-07-01 06:31:46 +02:00
return rcode;
}
2011-07-02 04:25:50 +02:00
/* Extracts bulk-IN and bulk-OUT endpoint information from config descriptor */
void ADK::EndpointXtract(uint8_t conf, uint8_t iface, uint8_t alt, uint8_t proto, const USB_ENDPOINT_DESCRIPTOR *pep)
{
2011-07-07 03:48:43 +02:00
//ErrorMessage<uint8_t>(PSTR("Conf.Val"), conf);
//ErrorMessage<uint8_t>(PSTR("Iface Num"),iface);
//ErrorMessage<uint8_t>(PSTR("Alt.Set"), alt);
//added by Yuuichi Akagawa
if( bNumEP == 3 ) {
return;
}
2011-07-02 04:25:50 +02:00
bConfNum = conf;
uint8_t index;
2011-07-02 08:45:36 +02:00
2011-07-02 04:25:50 +02:00
if ((pep->bmAttributes & 0x02) == 2) {
index = ((pep->bEndpointAddress & 0x80) == 0x80) ? epDataInIndex : epDataOutIndex;
}
// Fill in the endpoint info structure
epInfo[index].epAddr = (pep->bEndpointAddress & 0x0F);
epInfo[index].maxPktSize = (uint8_t)pep->wMaxPacketSize;
bNumEP ++;
2011-07-01 06:31:46 +02:00
2011-07-07 03:48:43 +02:00
//PrintEndpointDescriptor(pep);
2011-07-02 04:25:50 +02:00
}
/* Performs a cleanup after failed Init() attempt */
2011-07-01 06:31:46 +02:00
uint8_t ADK::Release()
{
2011-07-02 04:25:50 +02:00
pUsb->GetAddressPool().FreeAddress(bAddress);
2011-07-07 03:48:43 +02:00
2011-07-02 04:25:50 +02:00
bNumEP = 1; //must have to be reset to 1
2011-07-07 03:48:43 +02:00
2011-07-02 04:25:50 +02:00
bAddress = 0;
2011-07-07 03:48:43 +02:00
ready = false;
2011-07-01 06:31:46 +02:00
return 0;
}
uint8_t ADK::RcvData(uint16_t *bytes_rcvd, uint8_t *dataptr)
{
2011-07-07 03:48:43 +02:00
//USBTRACE2("\r\nAddr: ", bAddress );
//USBTRACE2("\r\nEP: ",epInfo[epDataInIndex].epAddr);
2011-07-01 06:31:46 +02:00
return pUsb->inTransfer(bAddress, epInfo[epDataInIndex].epAddr, bytes_rcvd, dataptr);
}
uint8_t ADK::SndData(uint16_t nbytes, uint8_t *dataptr)
{
return pUsb->outTransfer(bAddress, epInfo[epDataOutIndex].epAddr, nbytes, dataptr);
}
2011-07-02 04:25:50 +02:00
void ADK::PrintEndpointDescriptor( const USB_ENDPOINT_DESCRIPTOR* ep_ptr )
{
Notify(PSTR("Endpoint descriptor:"));
Notify(PSTR("\r\nLength:\t\t"));
PrintHex<uint8_t>(ep_ptr->bLength);
Notify(PSTR("\r\nType:\t\t"));
PrintHex<uint8_t>(ep_ptr->bDescriptorType);
Notify(PSTR("\r\nAddress:\t"));
PrintHex<uint8_t>(ep_ptr->bEndpointAddress);
Notify(PSTR("\r\nAttributes:\t"));
PrintHex<uint8_t>(ep_ptr->bmAttributes);
Notify(PSTR("\r\nMaxPktSize:\t"));
PrintHex<uint16_t>(ep_ptr->wMaxPacketSize);
Notify(PSTR("\r\nPoll Intrv:\t"));
PrintHex<uint8_t>(ep_ptr->bInterval);
Notify(PSTR("\r\n"));
}