BaseDAP.cpp

00001 // BaseDAP.cpp 2013/9/14
00002 #include "BaseDAP.h"
00003 
00004 BaseDAP::BaseDAP(SWD* swd) : _swd(swd)
00005 {
00006 }
00007 
00008 BaseDAP::~BaseDAP()
00009 {
00010 }
00011 
00012 int BaseDAP::Command(uint8_t* request, uint8_t* response)
00013 {
00014     switch(*request) {
00015         case 0x00: return Info(request, response);
00016         case 0x01: return LED(request, response); 
00017         case 0x02: return Connect(request, response); 
00018         case 0x03: return Disconnect(request, response);
00019         case 0x04: return TransferConfigure(request, response);
00020         case 0x05: return Transfer(request, response);
00021         case 0x06: return TransferBlock(request, response);
00022 
00023         case 0x08: return WriteABORT(request, response);
00024     
00025         case 0x10: return SWJ_Pins(request, response);
00026         case 0x11: return SWJ_Clock(request, response);
00027         case 0x12: return SWJ_Sequence(request, response);
00028         case 0x13: return SWD_Configure(request, response);
00029         
00030         case 0x80 ... 0x9f: return Vendor(request, response);
00031     };
00032     return Invalid(request, response);
00033 }
00034 
00035 /* virtual */ const char* BaseDAP::getInfo(int id)
00036 {
00037     const char* info_str[] = {
00038         NULL,     // 1 VENDOR
00039         NULL,     // 2 PRODUCT
00040         NULL,     // 3 SER_NUM
00041         "1.0",    // 4 FW_VER
00042         NULL,     // 5 DEVICE_VENDOR
00043         NULL,     // 6 DEVICE_NAME
00044     };
00045     if (id >= 1 && id <= 6) {
00046         return info_str[id-1];
00047     }
00048     return NULL;
00049 }
00050 
00051 /* virtual */ int BaseDAP::Info(uint8_t* request, uint8_t* response) // 0x00
00052 {
00053     const char* s;
00054     int slen;
00055     response[0] = 0x00; // Info
00056     int length = 2;
00057     int id = request[1];
00058     switch(id) {
00059         case 1 ... 6: // VENDOR PRODUCT SER_NUM FW_VER DEVICE_VENDOR DEVICE_NAME
00060             slen = 0;
00061             s = getInfo(id);
00062             if (s) {     
00063                 slen = strlen(s) + 1;
00064                 memcpy(response+2, s, slen);
00065             }
00066             response[1] = slen;    
00067             length += slen;
00068             break;
00069         case 0xf0:          // CAPABILITIES
00070             response[1] = sizeof(uint8_t);
00071             response[2] = 0x01; // SWD
00072             length += sizeof(uint8_t);
00073             break;
00074         case 0xfe:          // PACKET_COUNT
00075             response[1] = sizeof(uint8_t);
00076             response[2] = 1;
00077             length += sizeof(uint8_t);
00078             break;
00079         case 0xff:          // PACKET_SIZE
00080             response[1] = sizeof(uint16_t);
00081             ST<uint16_t>(response+2, 64);
00082             length += sizeof(uint16_t);
00083             break;
00084         default:
00085             response[1] = DAP_ERROR;
00086             break;
00087     }
00088     return length;
00089 }
00090 
00091 /* virtual */ void BaseDAP::infoLED(int select, int value)
00092 {
00093 }
00094 
00095 int BaseDAP::LED(uint8_t* request, uint8_t* response) // 0x01
00096 {
00097     infoLED(request[1], request[2]&1);
00098     response[0] = 0x01; // LED
00099     response[1] = DAP_OK;
00100     return 2;
00101 }
00102    
00103 int BaseDAP::Connect(uint8_t* request, uint8_t* response) // 0x02
00104 {
00105     response[0] = 0x02; // Connect
00106     response[1] = DAP_PORT_DISABLED;
00107     if (_swd) {
00108         if (request[1] == DAP_PORT_AUTODETECT || request[1] == DAP_PORT_SWD) {
00109             response[1] = DAP_PORT_SWD;
00110             _swd->Setup();
00111         }
00112     }
00113     return 2;
00114 }
00115 
00116 int BaseDAP::Disconnect(uint8_t* request, uint8_t* response) // 0x03
00117 {
00118     response[0] = 0x03; // disconnect
00119     response[1] = DAP_OK;
00120     return 2;
00121 }
00122 
00123 int BaseDAP::TransferConfigure(uint8_t* request, uint8_t* response) // 0x04
00124 {
00125     uint8_t idle_cycles = request[1];
00126     uint16_t retry_count = LD<uint16_t>(request+2);
00127     transfer.match_retry = LD<uint16_t>(request+4);
00128     _swd->TransferConfigure(idle_cycles, retry_count);
00129     response[0] = 0x04; //tansfer configure
00130     response[1] = DAP_OK;
00131     return 2;
00132 }
00133 
00134 int BaseDAP::Transfer(uint8_t* request, uint8_t* response) // 0x05
00135 {
00136     return transfer.Transfer(_swd, request, response);
00137 }
00138 
00139 int BaseDAP::TransferBlock(uint8_t* request, uint8_t* response) // 0x06
00140 {
00141     return transfer.TransferBlock(_swd, request, response);
00142 }
00143 
00144 int BaseDAP::WriteABORT(uint8_t* request, uint8_t* response) // 0x08
00145 {
00146     uint32_t data = LD<uint32_t>(request+2);
00147     uint8_t ack = _swd->Transfer(DP_ABORT, &data);
00148     response[0] = 0x08; // write abort
00149     response[1] = ack == SWD_OK ? DAP_OK : DAP_ERROR;
00150     return 2;
00151 }
00152 
00153 int BaseDAP::Delay(uint8_t* request, uint8_t* response) // 0x09
00154 {
00155     int waittime_ms = LD<uint16_t>(request+1);
00156     wait_ms(waittime_ms);
00157     response[0] = 0x09;
00158     response[1] = DAP_OK;
00159     return 2;
00160 }
00161 
00162 int BaseDAP::ResetTarget(uint8_t* request, uint8_t* response) // 0x0A
00163 {
00164     response[0] = 0x0a;
00165     response[1] = 0;
00166     response[2] = DAP_OK;
00167     return 3;
00168 }
00169 
00170 int BaseDAP::SWJ_Pins(uint8_t* request, uint8_t* response) // 0x10
00171 {
00172     uint32_t value = request[1];
00173     uint32_t select = request[2];
00174     uint32_t waittime_us = LD<uint32_t>(request+3);
00175     response[0] = 0x10; // swj pins
00176     response[1] = _swd->SWJPins(value, select, waittime_us);
00177     return 2;    
00178 }
00179 
00180 int BaseDAP::SWJ_Clock(uint8_t* request, uint8_t* response) // 0x11
00181 {
00182     uint32_t clock = LD<uint32_t>(request+1);
00183     _swd->SWJClock(clock);
00184     response[0] = 0x11; // swj clock
00185     response[1] = DAP_OK;
00186     return 2;
00187 }
00188 
00189 int BaseDAP::SWJ_Sequence(uint8_t* request, uint8_t* response) // 0x12
00190 {
00191     int count = request[1];
00192     if (count == 0) {
00193         count = 256;
00194     }
00195     _swd->SWJSequence(count, request+2);
00196     response[0] = 0x12; // swj sequence
00197     response[1] = DAP_OK;
00198     return 2;
00199 }
00200 
00201 int BaseDAP::SWD_Configure(uint8_t* request, uint8_t* response) // 0x13
00202 {
00203     uint8_t cfg = request[1];
00204     _swd->Configure((cfg&0x03)+1, cfg&0x04 ? 1: 0); 
00205     response[0] = 0x13; // swd configure
00206     response[1] = DAP_OK;
00207     return 2;
00208 }
00209 
00210 /* virtual */ int BaseDAP::Vendor(uint8_t* request, uint8_t* response) // 0x80 ... 0x9f
00211 {
00212     switch(request[0]) {
00213         case 0x80: return Vendor0(request, response);
00214     }
00215     response[0] = 0xff; // invalid
00216     return 1;    
00217 }
00218 
00219 int BaseDAP::Vendor0(uint8_t* request, uint8_t* response) // 0x80
00220 {
00221     const char* board_id = "1040123456789"; // lpc11u24
00222     int len = strlen(board_id);
00223     response[0] = 0x80;
00224     response[1] = len;
00225     memcpy(response+2, board_id, len);  
00226     return len + 1;
00227 }
00228 
00229 /* virtual */ int BaseDAP::Invalid(uint8_t* request, uint8_t* response)
00230 {
00231     response[0] = 0xff; // invalid
00232     return 1;    
00233 }