1c120c564SAndrew Turner /*
2c120c564SAndrew Turner * \file trc_pkt_proc_ptm.cpp
3c120c564SAndrew Turner * \brief OpenCSD :
4c120c564SAndrew Turner *
5c120c564SAndrew Turner * \copyright Copyright (c) 2015, ARM Limited. All Rights Reserved.
6c120c564SAndrew Turner */
7c120c564SAndrew Turner
8c120c564SAndrew Turner /*
9c120c564SAndrew Turner * Redistribution and use in source and binary forms, with or without modification,
10c120c564SAndrew Turner * are permitted provided that the following conditions are met:
11c120c564SAndrew Turner *
12c120c564SAndrew Turner * 1. Redistributions of source code must retain the above copyright notice,
13c120c564SAndrew Turner * this list of conditions and the following disclaimer.
14c120c564SAndrew Turner *
15c120c564SAndrew Turner * 2. Redistributions in binary form must reproduce the above copyright notice,
16c120c564SAndrew Turner * this list of conditions and the following disclaimer in the documentation
17c120c564SAndrew Turner * and/or other materials provided with the distribution.
18c120c564SAndrew Turner *
19c120c564SAndrew Turner * 3. Neither the name of the copyright holder nor the names of its contributors
20c120c564SAndrew Turner * may be used to endorse or promote products derived from this software without
21c120c564SAndrew Turner * specific prior written permission.
22c120c564SAndrew Turner *
23c120c564SAndrew Turner * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
24c120c564SAndrew Turner * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
25c120c564SAndrew Turner * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26c120c564SAndrew Turner * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
27c120c564SAndrew Turner * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
28c120c564SAndrew Turner * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
29c120c564SAndrew Turner * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
30c120c564SAndrew Turner * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31c120c564SAndrew Turner * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
32c120c564SAndrew Turner * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33c120c564SAndrew Turner */
34c120c564SAndrew Turner
35c120c564SAndrew Turner #include "opencsd/ptm/trc_pkt_proc_ptm.h"
36c120c564SAndrew Turner #include "opencsd/ptm/trc_cmp_cfg_ptm.h"
37c120c564SAndrew Turner #include "common/ocsd_error.h"
38c120c564SAndrew Turner
39c120c564SAndrew Turner
40c120c564SAndrew Turner #ifdef __GNUC__
41c120c564SAndrew Turner // G++ doesn't like the ## pasting
42c120c564SAndrew Turner #define PTM_PKTS_NAME "PKTP_PTM"
43c120c564SAndrew Turner #else
44c120c564SAndrew Turner // VC++ is OK
45c120c564SAndrew Turner #define PTM_PKTS_NAME OCSD_CMPNAME_PREFIX_PKTPROC##"_PTM"
46c120c564SAndrew Turner #endif
47c120c564SAndrew Turner
TrcPktProcPtm()48c120c564SAndrew Turner TrcPktProcPtm::TrcPktProcPtm() : TrcPktProcBase(PTM_PKTS_NAME)
49c120c564SAndrew Turner {
50c120c564SAndrew Turner InitProcessorState();
51c120c564SAndrew Turner BuildIPacketTable();
52c120c564SAndrew Turner }
53c120c564SAndrew Turner
TrcPktProcPtm(int instIDNum)54c120c564SAndrew Turner TrcPktProcPtm::TrcPktProcPtm(int instIDNum) : TrcPktProcBase(PTM_PKTS_NAME, instIDNum)
55c120c564SAndrew Turner {
56c120c564SAndrew Turner InitProcessorState();
57c120c564SAndrew Turner BuildIPacketTable();
58c120c564SAndrew Turner }
59c120c564SAndrew Turner
~TrcPktProcPtm()60c120c564SAndrew Turner TrcPktProcPtm::~TrcPktProcPtm()
61c120c564SAndrew Turner {
62c120c564SAndrew Turner
63c120c564SAndrew Turner }
64c120c564SAndrew Turner
onProtocolConfig()65c120c564SAndrew Turner ocsd_err_t TrcPktProcPtm::onProtocolConfig()
66c120c564SAndrew Turner {
67c120c564SAndrew Turner ocsd_err_t err = OCSD_ERR_NOT_INIT;
68c120c564SAndrew Turner
69c120c564SAndrew Turner if(m_config != 0)
70c120c564SAndrew Turner {
71c120c564SAndrew Turner m_chanIDCopy = m_config->getTraceID();
72c120c564SAndrew Turner err = OCSD_OK;
73c120c564SAndrew Turner }
74c120c564SAndrew Turner return err;
75c120c564SAndrew Turner }
76c120c564SAndrew Turner
processData(const ocsd_trc_index_t index,const uint32_t dataBlockSize,const uint8_t * pDataBlock,uint32_t * numBytesProcessed)77c120c564SAndrew Turner ocsd_datapath_resp_t TrcPktProcPtm::processData( const ocsd_trc_index_t index,
78c120c564SAndrew Turner const uint32_t dataBlockSize,
79c120c564SAndrew Turner const uint8_t *pDataBlock,
80c120c564SAndrew Turner uint32_t *numBytesProcessed)
81c120c564SAndrew Turner {
82c120c564SAndrew Turner ocsd_datapath_resp_t resp = OCSD_RESP_CONT;
83c120c564SAndrew Turner uint8_t currByte = 0;
84c120c564SAndrew Turner
85c120c564SAndrew Turner m_dataInProcessed = 0;
86c120c564SAndrew Turner
87c120c564SAndrew Turner if(!checkInit())
88c120c564SAndrew Turner {
89c120c564SAndrew Turner resp = OCSD_RESP_FATAL_NOT_INIT;
90c120c564SAndrew Turner }
91c120c564SAndrew Turner else
92c120c564SAndrew Turner {
93c120c564SAndrew Turner m_pDataIn = pDataBlock;
94c120c564SAndrew Turner m_dataInLen = dataBlockSize;
95c120c564SAndrew Turner m_block_idx = index; // index start for current block
96c120c564SAndrew Turner }
97c120c564SAndrew Turner
98c120c564SAndrew Turner while( ( ( m_dataInProcessed < dataBlockSize) ||
99c120c564SAndrew Turner (( m_dataInProcessed == dataBlockSize) && (m_process_state == SEND_PKT)) ) &&
100c120c564SAndrew Turner OCSD_DATA_RESP_IS_CONT(resp))
101c120c564SAndrew Turner {
102c120c564SAndrew Turner try
103c120c564SAndrew Turner {
104c120c564SAndrew Turner switch(m_process_state)
105c120c564SAndrew Turner {
106c120c564SAndrew Turner case WAIT_SYNC:
107c120c564SAndrew Turner if(!m_waitASyncSOPkt)
108c120c564SAndrew Turner {
109c120c564SAndrew Turner m_curr_pkt_index = m_block_idx + m_dataInProcessed;
110c120c564SAndrew Turner m_curr_packet.type = PTM_PKT_NOTSYNC;
111c120c564SAndrew Turner m_bAsyncRawOp = hasRawMon();
112c120c564SAndrew Turner }
113c120c564SAndrew Turner resp = waitASync();
114c120c564SAndrew Turner break;
115c120c564SAndrew Turner
116c120c564SAndrew Turner case PROC_HDR:
117c120c564SAndrew Turner m_curr_pkt_index = m_block_idx + m_dataInProcessed;
118c120c564SAndrew Turner if(readByte(currByte))
119c120c564SAndrew Turner {
120c120c564SAndrew Turner m_pIPktFn = m_i_table[currByte].pptkFn;
121c120c564SAndrew Turner m_curr_packet.type = m_i_table[currByte].pkt_type;
122c120c564SAndrew Turner }
123c120c564SAndrew Turner else
124c120c564SAndrew Turner {
125c120c564SAndrew Turner // sequencing error - should not get to the point where readByte
126c120c564SAndrew Turner // fails and m_DataInProcessed < dataBlockSize
127c120c564SAndrew Turner // throw data overflow error
128c120c564SAndrew Turner throw ocsdError(OCSD_ERR_SEV_ERROR,OCSD_ERR_PKT_INTERP_FAIL,m_curr_pkt_index,this->m_chanIDCopy,"Data Buffer Overrun");
129c120c564SAndrew Turner }
130c120c564SAndrew Turner m_process_state = PROC_DATA;
131c120c564SAndrew Turner
132c120c564SAndrew Turner case PROC_DATA:
133c120c564SAndrew Turner (this->*m_pIPktFn)();
134c120c564SAndrew Turner break;
135c120c564SAndrew Turner
136c120c564SAndrew Turner case SEND_PKT:
137c120c564SAndrew Turner resp = outputPacket();
138c120c564SAndrew Turner InitPacketState();
139c120c564SAndrew Turner m_process_state = PROC_HDR;
140c120c564SAndrew Turner break;
141c120c564SAndrew Turner }
142c120c564SAndrew Turner }
143c120c564SAndrew Turner catch(ocsdError &err)
144c120c564SAndrew Turner {
145c120c564SAndrew Turner LogError(err);
146c120c564SAndrew Turner if( (err.getErrorCode() == OCSD_ERR_BAD_PACKET_SEQ) ||
147c120c564SAndrew Turner (err.getErrorCode() == OCSD_ERR_INVALID_PCKT_HDR))
148c120c564SAndrew Turner {
149c120c564SAndrew Turner // send invalid packets up the pipe to let the next stage decide what to do.
150c120c564SAndrew Turner m_process_state = SEND_PKT;
151c120c564SAndrew Turner }
152c120c564SAndrew Turner else
153c120c564SAndrew Turner {
154c120c564SAndrew Turner // bail out on any other error.
155c120c564SAndrew Turner resp = OCSD_RESP_FATAL_INVALID_DATA;
156c120c564SAndrew Turner }
157c120c564SAndrew Turner }
158c120c564SAndrew Turner catch(...)
159c120c564SAndrew Turner {
160c120c564SAndrew Turner /// vv bad at this point.
161c120c564SAndrew Turner resp = OCSD_RESP_FATAL_SYS_ERR;
162c120c564SAndrew Turner const ocsdError &fatal = ocsdError(OCSD_ERR_SEV_ERROR,OCSD_ERR_FAIL,m_curr_pkt_index,m_chanIDCopy,"Unknown System Error decoding trace.");
163c120c564SAndrew Turner LogError(fatal);
164c120c564SAndrew Turner }
165c120c564SAndrew Turner
166c120c564SAndrew Turner }
167c120c564SAndrew Turner *numBytesProcessed = m_dataInProcessed;
168c120c564SAndrew Turner return resp;
169c120c564SAndrew Turner }
170c120c564SAndrew Turner
onEOT()171c120c564SAndrew Turner ocsd_datapath_resp_t TrcPktProcPtm::onEOT()
172c120c564SAndrew Turner {
173c120c564SAndrew Turner ocsd_datapath_resp_t err = OCSD_RESP_FATAL_NOT_INIT;
174c120c564SAndrew Turner if(checkInit())
175c120c564SAndrew Turner {
176c120c564SAndrew Turner err = OCSD_RESP_CONT;
177c120c564SAndrew Turner if(m_currPacketData.size() > 0)
178c120c564SAndrew Turner {
179c120c564SAndrew Turner m_curr_packet.SetErrType(PTM_PKT_INCOMPLETE_EOT);
180c120c564SAndrew Turner err = outputPacket();
181c120c564SAndrew Turner }
182c120c564SAndrew Turner }
183c120c564SAndrew Turner return err;
184c120c564SAndrew Turner }
185c120c564SAndrew Turner
onReset()186c120c564SAndrew Turner ocsd_datapath_resp_t TrcPktProcPtm::onReset()
187c120c564SAndrew Turner {
188c120c564SAndrew Turner ocsd_datapath_resp_t err = OCSD_RESP_FATAL_NOT_INIT;
189c120c564SAndrew Turner if(checkInit())
190c120c564SAndrew Turner {
191c120c564SAndrew Turner InitProcessorState();
192c120c564SAndrew Turner err = OCSD_RESP_CONT;
193c120c564SAndrew Turner }
194c120c564SAndrew Turner return err;
195c120c564SAndrew Turner }
196c120c564SAndrew Turner
onFlush()197c120c564SAndrew Turner ocsd_datapath_resp_t TrcPktProcPtm::onFlush()
198c120c564SAndrew Turner {
199c120c564SAndrew Turner ocsd_datapath_resp_t err = OCSD_RESP_FATAL_NOT_INIT;
200c120c564SAndrew Turner if(checkInit())
201c120c564SAndrew Turner {
202c120c564SAndrew Turner err = OCSD_RESP_CONT;
203c120c564SAndrew Turner }
204c120c564SAndrew Turner return err;
205c120c564SAndrew Turner }
206c120c564SAndrew Turner
isBadPacket() const207c120c564SAndrew Turner const bool TrcPktProcPtm::isBadPacket() const
208c120c564SAndrew Turner {
209c120c564SAndrew Turner return m_curr_packet.isBadPacket();
210c120c564SAndrew Turner }
211c120c564SAndrew Turner
InitPacketState()212c120c564SAndrew Turner void TrcPktProcPtm::InitPacketState()
213c120c564SAndrew Turner {
214c120c564SAndrew Turner m_curr_packet.Clear();
215c120c564SAndrew Turner
216c120c564SAndrew Turner }
217c120c564SAndrew Turner
InitProcessorState()218c120c564SAndrew Turner void TrcPktProcPtm::InitProcessorState()
219c120c564SAndrew Turner {
220c120c564SAndrew Turner m_curr_packet.SetType(PTM_PKT_NOTSYNC);
221c120c564SAndrew Turner m_pIPktFn = &TrcPktProcPtm::pktReserved;
222c120c564SAndrew Turner m_process_state = WAIT_SYNC;
223c120c564SAndrew Turner m_async_0 = 0;
224c120c564SAndrew Turner m_waitASyncSOPkt = false;
225c120c564SAndrew Turner m_bAsyncRawOp = false;
226c120c564SAndrew Turner m_bOPNotSyncPkt = false;
227*46e6e290SRuslan Bukin m_excepAltISA = 0;
228c120c564SAndrew Turner
229c120c564SAndrew Turner m_curr_packet.ResetState();
230c120c564SAndrew Turner InitPacketState();
231c120c564SAndrew Turner }
232c120c564SAndrew Turner
readByte(uint8_t & currByte)233c120c564SAndrew Turner const bool TrcPktProcPtm::readByte(uint8_t &currByte)
234c120c564SAndrew Turner {
235c120c564SAndrew Turner bool bValidByte = false;
236c120c564SAndrew Turner
237c120c564SAndrew Turner if(m_dataInProcessed < m_dataInLen)
238c120c564SAndrew Turner {
239c120c564SAndrew Turner currByte = m_pDataIn[m_dataInProcessed++];
240c120c564SAndrew Turner m_currPacketData.push_back(currByte);
241c120c564SAndrew Turner bValidByte = true;
242c120c564SAndrew Turner }
243c120c564SAndrew Turner return bValidByte;
244c120c564SAndrew Turner }
245c120c564SAndrew Turner
unReadByte()246c120c564SAndrew Turner void TrcPktProcPtm::unReadByte()
247c120c564SAndrew Turner {
248c120c564SAndrew Turner m_dataInProcessed--;
249c120c564SAndrew Turner m_currPacketData.pop_back();
250c120c564SAndrew Turner }
251c120c564SAndrew Turner
outputPacket()252c120c564SAndrew Turner ocsd_datapath_resp_t TrcPktProcPtm::outputPacket()
253c120c564SAndrew Turner {
254c120c564SAndrew Turner ocsd_datapath_resp_t resp = OCSD_RESP_CONT;
255c120c564SAndrew Turner resp = outputOnAllInterfaces(m_curr_pkt_index,&m_curr_packet,&m_curr_packet.type,m_currPacketData);
256c120c564SAndrew Turner m_currPacketData.clear();
257c120c564SAndrew Turner return resp;
258c120c564SAndrew Turner }
259c120c564SAndrew Turner
260c120c564SAndrew Turner /*** sync and packet functions ***/
waitASync()261c120c564SAndrew Turner ocsd_datapath_resp_t TrcPktProcPtm::waitASync()
262c120c564SAndrew Turner {
263c120c564SAndrew Turner ocsd_datapath_resp_t resp = OCSD_RESP_CONT;
264c120c564SAndrew Turner
265c120c564SAndrew Turner // looking for possible patterns in input buffer:-
266c120c564SAndrew Turner // a) ASYNC @ start : 00 00 00 00 00 80
267c120c564SAndrew Turner // b) unsync then async: xx xx xx xx xx xx xx xx 00 00 00 00 00 80
268c120c564SAndrew Turner // c) unsync (may have 00) xx xx xx xx 00 xx xx 00 00 00 xx xx xx xx
269c120c564SAndrew Turner // d) unsync then part async: xx xx xx xx xx xx xx xx xx xx xx 00 00 00
270c120c564SAndrew Turner // e) unsync with prev part async [00 00 00] 00 xx xx xx xx xx xx xx xx [] = byte in previous input buffer
271c120c564SAndrew Turner
272c120c564SAndrew Turner // bytes to read before throwing an unsynced packet
273c120c564SAndrew Turner #define UNSYNC_PKT_MAX 16
274c120c564SAndrew Turner static const uint8_t spare_zeros[] = { 0,0,0,0,0,0,0,0,
275c120c564SAndrew Turner 0,0,0,0,0,0,0,0 };
276c120c564SAndrew Turner
277c120c564SAndrew Turner bool doScan = true;
278c120c564SAndrew Turner bool bSendUnsyncedData = false;
279c120c564SAndrew Turner bool bHaveASync = false;
280c120c564SAndrew Turner int unsynced_bytes = 0;
281c120c564SAndrew Turner int unsync_scan_block_start = 0;
282c120c564SAndrew Turner int pktBytesOnEntry = m_currPacketData.size(); // did we have part of a potential async last time?
283c120c564SAndrew Turner
284c120c564SAndrew Turner while(doScan && OCSD_DATA_RESP_IS_CONT(resp))
285c120c564SAndrew Turner {
286c120c564SAndrew Turner // may have spotted the start of an async
287c120c564SAndrew Turner if(m_waitASyncSOPkt == true)
288c120c564SAndrew Turner {
289c120c564SAndrew Turner switch(findAsync())
290c120c564SAndrew Turner {
291c120c564SAndrew Turner case ASYNC:
292c120c564SAndrew Turner case ASYNC_EXTRA_0:
293c120c564SAndrew Turner m_process_state = SEND_PKT;
294c120c564SAndrew Turner m_waitASyncSOPkt = false;
295c120c564SAndrew Turner bSendUnsyncedData = true;
296c120c564SAndrew Turner bHaveASync = true;
297c120c564SAndrew Turner doScan = false;
298c120c564SAndrew Turner break;
299c120c564SAndrew Turner
300c120c564SAndrew Turner case THROW_0:
301c120c564SAndrew Turner // remove a bunch of 0s
302c120c564SAndrew Turner unsynced_bytes += ASYNC_PAD_0_LIMIT;
303c120c564SAndrew Turner m_waitASyncSOPkt = false;
304c120c564SAndrew Turner m_currPacketData.erase( m_currPacketData.begin(), m_currPacketData.begin()+ASYNC_PAD_0_LIMIT);
305c120c564SAndrew Turner break;
306c120c564SAndrew Turner
307c120c564SAndrew Turner case NOT_ASYNC:
308c120c564SAndrew Turner unsynced_bytes += m_currPacketData.size();
309c120c564SAndrew Turner m_waitASyncSOPkt = false;
310c120c564SAndrew Turner m_currPacketData.clear();
311c120c564SAndrew Turner break;
312c120c564SAndrew Turner
313c120c564SAndrew Turner case ASYNC_INCOMPLETE:
314c120c564SAndrew Turner bSendUnsyncedData = true;
315c120c564SAndrew Turner doScan = false;
316c120c564SAndrew Turner break;
317c120c564SAndrew Turner }
318c120c564SAndrew Turner }
319c120c564SAndrew Turner else
320c120c564SAndrew Turner {
321c120c564SAndrew Turner if(m_pDataIn[m_dataInProcessed++] == 0x00)
322c120c564SAndrew Turner {
323c120c564SAndrew Turner m_waitASyncSOPkt = true;
324c120c564SAndrew Turner m_currPacketData.push_back(0);
325c120c564SAndrew Turner m_async_0 = 1;
326c120c564SAndrew Turner }
327c120c564SAndrew Turner else
328c120c564SAndrew Turner {
329c120c564SAndrew Turner unsynced_bytes++;
330c120c564SAndrew Turner }
331c120c564SAndrew Turner }
332c120c564SAndrew Turner
333c120c564SAndrew Turner // may need to send some unsynced data here, either if we have enought to make it worthwhile,
334c120c564SAndrew Turner // or are at the end of the buffer.
335c120c564SAndrew Turner if(unsynced_bytes >= UNSYNC_PKT_MAX)
336c120c564SAndrew Turner bSendUnsyncedData = true;
337c120c564SAndrew Turner
338c120c564SAndrew Turner if(m_dataInProcessed == m_dataInLen)
339c120c564SAndrew Turner {
340c120c564SAndrew Turner bSendUnsyncedData = true;
341c120c564SAndrew Turner doScan = false; // no more data available - stop the scan
342c120c564SAndrew Turner }
343c120c564SAndrew Turner
344c120c564SAndrew Turner // will send any unsynced data
345c120c564SAndrew Turner if(bSendUnsyncedData && (unsynced_bytes > 0))
346c120c564SAndrew Turner {
347c120c564SAndrew Turner if(m_bAsyncRawOp)
348c120c564SAndrew Turner {
349c120c564SAndrew Turner // there were some 0's in the packet buyffer from the last pass that are no longer in the raw buffer,
350c120c564SAndrew Turner // and these turned out not to be an async
351c120c564SAndrew Turner if(pktBytesOnEntry)
352c120c564SAndrew Turner {
353c120c564SAndrew Turner outputRawPacketToMonitor(m_curr_pkt_index,&m_curr_packet,pktBytesOnEntry,spare_zeros);
354c120c564SAndrew Turner m_curr_pkt_index += pktBytesOnEntry;
355c120c564SAndrew Turner }
356c120c564SAndrew Turner outputRawPacketToMonitor(m_curr_pkt_index,&m_curr_packet,unsynced_bytes,m_pDataIn+unsync_scan_block_start);
357c120c564SAndrew Turner }
358c120c564SAndrew Turner if (!m_bOPNotSyncPkt)
359c120c564SAndrew Turner {
360c120c564SAndrew Turner resp = outputDecodedPacket(m_curr_pkt_index, &m_curr_packet);
361c120c564SAndrew Turner m_bOPNotSyncPkt = true;
362c120c564SAndrew Turner }
363c120c564SAndrew Turner unsync_scan_block_start += unsynced_bytes;
364c120c564SAndrew Turner m_curr_pkt_index+= unsynced_bytes;
365c120c564SAndrew Turner unsynced_bytes = 0;
366c120c564SAndrew Turner bSendUnsyncedData = false;
367c120c564SAndrew Turner }
368c120c564SAndrew Turner
369c120c564SAndrew Turner // mark next packet as the ASYNC we are looking for.
370c120c564SAndrew Turner if(bHaveASync)
371c120c564SAndrew Turner m_curr_packet.SetType(PTM_PKT_A_SYNC);
372c120c564SAndrew Turner }
373c120c564SAndrew Turner
374c120c564SAndrew Turner return resp;
375c120c564SAndrew Turner }
376c120c564SAndrew Turner
pktASync()377c120c564SAndrew Turner void TrcPktProcPtm::pktASync()
378c120c564SAndrew Turner {
379c120c564SAndrew Turner if(m_currPacketData.size() == 1) // header byte
380c120c564SAndrew Turner {
381c120c564SAndrew Turner m_async_0 = 1;
382c120c564SAndrew Turner }
383c120c564SAndrew Turner
384c120c564SAndrew Turner switch(findAsync())
385c120c564SAndrew Turner {
386c120c564SAndrew Turner case ASYNC:
387c120c564SAndrew Turner case ASYNC_EXTRA_0:
388c120c564SAndrew Turner m_process_state = SEND_PKT;
389c120c564SAndrew Turner break;
390c120c564SAndrew Turner
391c120c564SAndrew Turner case THROW_0:
392c120c564SAndrew Turner case NOT_ASYNC:
393c120c564SAndrew Turner throwMalformedPacketErr("Bad Async packet");
394c120c564SAndrew Turner break;
395c120c564SAndrew Turner
396c120c564SAndrew Turner case ASYNC_INCOMPLETE:
397c120c564SAndrew Turner break;
398c120c564SAndrew Turner
399c120c564SAndrew Turner }
400c120c564SAndrew Turner }
401c120c564SAndrew Turner
findAsync()402c120c564SAndrew Turner TrcPktProcPtm::async_result_t TrcPktProcPtm::findAsync()
403c120c564SAndrew Turner {
404c120c564SAndrew Turner async_result_t async_res = NOT_ASYNC;
405c120c564SAndrew Turner bool bFound = false; // found non-zero byte in sequence
406c120c564SAndrew Turner bool bByteAvail = true;
407c120c564SAndrew Turner uint8_t currByte;
408c120c564SAndrew Turner
409c120c564SAndrew Turner while(!bFound && bByteAvail)
410c120c564SAndrew Turner {
411c120c564SAndrew Turner if(readByte(currByte))
412c120c564SAndrew Turner {
413c120c564SAndrew Turner if(currByte == 0x00)
414c120c564SAndrew Turner {
415c120c564SAndrew Turner m_async_0++;
416c120c564SAndrew Turner if(m_async_0 >= (ASYNC_PAD_0_LIMIT + ASYNC_REQ_0))
417c120c564SAndrew Turner {
418c120c564SAndrew Turner bFound = true;
419c120c564SAndrew Turner async_res = THROW_0;
420c120c564SAndrew Turner }
421c120c564SAndrew Turner }
422c120c564SAndrew Turner else
423c120c564SAndrew Turner {
424c120c564SAndrew Turner if(currByte == 0x80)
425c120c564SAndrew Turner {
426c120c564SAndrew Turner if(m_async_0 == 5)
427c120c564SAndrew Turner async_res = ASYNC;
428c120c564SAndrew Turner else if(m_async_0 > 5)
429c120c564SAndrew Turner async_res = ASYNC_EXTRA_0;
430c120c564SAndrew Turner }
431c120c564SAndrew Turner bFound = true;
432c120c564SAndrew Turner }
433c120c564SAndrew Turner }
434c120c564SAndrew Turner else
435c120c564SAndrew Turner {
436c120c564SAndrew Turner bByteAvail = false;
437c120c564SAndrew Turner async_res = ASYNC_INCOMPLETE;
438c120c564SAndrew Turner }
439c120c564SAndrew Turner }
440c120c564SAndrew Turner return async_res;
441c120c564SAndrew Turner }
442c120c564SAndrew Turner
pktISync()443c120c564SAndrew Turner void TrcPktProcPtm::pktISync()
444c120c564SAndrew Turner {
445c120c564SAndrew Turner uint8_t currByte = 0;
446c120c564SAndrew Turner int pktIndex = m_currPacketData.size() - 1;
447c120c564SAndrew Turner bool bGotBytes = false, validByte = true;
448c120c564SAndrew Turner
449c120c564SAndrew Turner if(pktIndex == 0)
450c120c564SAndrew Turner {
451c120c564SAndrew Turner m_numCtxtIDBytes = m_config->CtxtIDBytes();
452c120c564SAndrew Turner m_gotCtxtIDBytes = 0;
453c120c564SAndrew Turner
454c120c564SAndrew Turner // total bytes = 6 + ctxtID; (perhaps more later)
455c120c564SAndrew Turner m_numPktBytesReq = 6 + m_numCtxtIDBytes;
456c120c564SAndrew Turner }
457c120c564SAndrew Turner
458c120c564SAndrew Turner while(validByte && !bGotBytes)
459c120c564SAndrew Turner {
460c120c564SAndrew Turner if(readByte(currByte))
461c120c564SAndrew Turner {
462c120c564SAndrew Turner pktIndex = m_currPacketData.size() - 1;
463c120c564SAndrew Turner if(pktIndex == 5)
464c120c564SAndrew Turner {
465c120c564SAndrew Turner // got the info byte
466c120c564SAndrew Turner int altISA = (currByte >> 2) & 0x1;
467c120c564SAndrew Turner int reason = (currByte >> 5) & 0x3;
468c120c564SAndrew Turner m_curr_packet.SetISyncReason((ocsd_iSync_reason)(reason));
469c120c564SAndrew Turner m_curr_packet.UpdateNS((currByte >> 3) & 0x1);
470c120c564SAndrew Turner m_curr_packet.UpdateAltISA((currByte >> 2) & 0x1);
471c120c564SAndrew Turner m_curr_packet.UpdateHyp((currByte >> 1) & 0x1);
472c120c564SAndrew Turner
473c120c564SAndrew Turner ocsd_isa isa = ocsd_isa_arm;
474c120c564SAndrew Turner if(m_currPacketData[1] & 0x1)
475c120c564SAndrew Turner isa = altISA ? ocsd_isa_tee : ocsd_isa_thumb2;
476c120c564SAndrew Turner m_curr_packet.UpdateISA(isa);
477c120c564SAndrew Turner
478c120c564SAndrew Turner // check cycle count required - not if reason == 0;
479c120c564SAndrew Turner m_needCycleCount = (reason != 0) ? m_config->enaCycleAcc() : false;
480c120c564SAndrew Turner m_gotCycleCount = false;
481c120c564SAndrew Turner m_numPktBytesReq += (m_needCycleCount ? 1 : 0);
482c120c564SAndrew Turner m_gotCCBytes = 0;
483c120c564SAndrew Turner
484c120c564SAndrew Turner }
485c120c564SAndrew Turner else if(pktIndex > 5)
486c120c564SAndrew Turner {
487c120c564SAndrew Turner // cycle count appears first if present
488c120c564SAndrew Turner if(m_needCycleCount && !m_gotCycleCount)
489c120c564SAndrew Turner {
490c120c564SAndrew Turner if(pktIndex == 6)
491c120c564SAndrew Turner m_gotCycleCount = (bool)((currByte & 0x40) == 0); // no cont bit, got cycle count
492c120c564SAndrew Turner else
493c120c564SAndrew Turner m_gotCycleCount = ((currByte & 0x80) == 0) || (pktIndex == 10);
494c120c564SAndrew Turner
495c120c564SAndrew Turner m_gotCCBytes++; // count the cycle count bytes for later use.
496c120c564SAndrew Turner if(!m_gotCycleCount) // need more cycle count bytes
497c120c564SAndrew Turner m_numPktBytesReq++;
498c120c564SAndrew Turner }
499c120c564SAndrew Turner // then context ID if present.
500c120c564SAndrew Turner else if( m_numCtxtIDBytes > m_gotCtxtIDBytes)
501c120c564SAndrew Turner {
502c120c564SAndrew Turner m_gotCtxtIDBytes++;
503c120c564SAndrew Turner }
504c120c564SAndrew Turner }
505c120c564SAndrew Turner
506c120c564SAndrew Turner // check if we have enough bytes
507c120c564SAndrew Turner bGotBytes = (bool)((unsigned)m_numPktBytesReq == m_currPacketData.size());
508c120c564SAndrew Turner }
509c120c564SAndrew Turner else
510c120c564SAndrew Turner validByte = false; // no byte available, exit.
511c120c564SAndrew Turner }
512c120c564SAndrew Turner
513c120c564SAndrew Turner if(bGotBytes)
514c120c564SAndrew Turner {
515c120c564SAndrew Turner // extract address value, cycle count and ctxt id.
516c120c564SAndrew Turner uint32_t cycleCount = 0;
517c120c564SAndrew Turner uint32_t ctxtID = 0;
518c120c564SAndrew Turner int optIdx = 6; // start index for optional elements.
519c120c564SAndrew Turner
520c120c564SAndrew Turner // address is always full fixed 32 bit value
521c120c564SAndrew Turner uint32_t address = ((uint32_t)m_currPacketData[1]) & 0xFE;
522c120c564SAndrew Turner address |= ((uint32_t)m_currPacketData[2]) << 8;
523c120c564SAndrew Turner address |= ((uint32_t)m_currPacketData[3]) << 16;
524c120c564SAndrew Turner address |= ((uint32_t)m_currPacketData[4]) << 24;
525c120c564SAndrew Turner m_curr_packet.UpdateAddress(address,32);
526c120c564SAndrew Turner
527c120c564SAndrew Turner if(m_needCycleCount)
528c120c564SAndrew Turner {
529c120c564SAndrew Turner extractCycleCount(optIdx,cycleCount);
530c120c564SAndrew Turner m_curr_packet.SetCycleCount(cycleCount);
531c120c564SAndrew Turner optIdx+=m_gotCCBytes;
532c120c564SAndrew Turner }
533c120c564SAndrew Turner
534c120c564SAndrew Turner if(m_numCtxtIDBytes)
535c120c564SAndrew Turner {
536c120c564SAndrew Turner extractCtxtID(optIdx,ctxtID);
537c120c564SAndrew Turner m_curr_packet.UpdateContextID(ctxtID);
538c120c564SAndrew Turner }
539c120c564SAndrew Turner m_process_state = SEND_PKT;
540c120c564SAndrew Turner }
541c120c564SAndrew Turner }
542c120c564SAndrew Turner
pktTrigger()543c120c564SAndrew Turner void TrcPktProcPtm::pktTrigger()
544c120c564SAndrew Turner {
545c120c564SAndrew Turner m_process_state = SEND_PKT; // no payload
546c120c564SAndrew Turner }
547c120c564SAndrew Turner
pktWPointUpdate()548c120c564SAndrew Turner void TrcPktProcPtm::pktWPointUpdate()
549c120c564SAndrew Turner {
550c120c564SAndrew Turner bool bDone = false;
551c120c564SAndrew Turner bool bBytesAvail = true;
552c120c564SAndrew Turner uint8_t currByte = 0;
553c120c564SAndrew Turner int byteIdx = 0;
554c120c564SAndrew Turner
555c120c564SAndrew Turner if(m_currPacketData.size() == 1)
556c120c564SAndrew Turner {
557c120c564SAndrew Turner m_gotAddrBytes = false; // flag to indicate got all needed address bytes
558c120c564SAndrew Turner m_numAddrBytes = 0; // number of address bytes so far - in this case header is not part of the address
559c120c564SAndrew Turner
560c120c564SAndrew Turner m_gotExcepBytes = false; // mark as not got all required exception bytes thus far
561c120c564SAndrew Turner m_numExcepBytes = 0; // 0 read in
562c120c564SAndrew Turner
563c120c564SAndrew Turner m_addrPktIsa = ocsd_isa_unknown; // not set by this packet as yet
564c120c564SAndrew Turner }
565c120c564SAndrew Turner
566c120c564SAndrew Turner // collect all the bytes needed
567c120c564SAndrew Turner while(!bDone && bBytesAvail)
568c120c564SAndrew Turner {
569c120c564SAndrew Turner if(readByte(currByte))
570c120c564SAndrew Turner {
571*46e6e290SRuslan Bukin
572c120c564SAndrew Turner byteIdx = m_currPacketData.size() - 1;
573c120c564SAndrew Turner if(!m_gotAddrBytes)
574c120c564SAndrew Turner {
575*46e6e290SRuslan Bukin // byteIdx for address byte will run from 1 to 5 - first 4 my have continuation or not.
576*46e6e290SRuslan Bukin if(byteIdx <= 4)
577c120c564SAndrew Turner {
578c120c564SAndrew Turner // address bytes 1 - 4;
579c120c564SAndrew Turner // ISA stays the same
580c120c564SAndrew Turner if((currByte & 0x80) == 0x00)
581c120c564SAndrew Turner {
582c120c564SAndrew Turner // no further bytes
583c120c564SAndrew Turner m_gotAddrBytes = true;
584c120c564SAndrew Turner bDone = true;
585c120c564SAndrew Turner m_gotExcepBytes = true;
586c120c564SAndrew Turner }
587c120c564SAndrew Turner }
588c120c564SAndrew Turner else
589c120c564SAndrew Turner {
590c120c564SAndrew Turner // 5th address byte - determine ISA from this.
591c120c564SAndrew Turner if((currByte & 0x40) == 0x00)
592c120c564SAndrew Turner m_gotExcepBytes = true; // no exception bytes - mark as done
593c120c564SAndrew Turner m_gotAddrBytes = true;
594c120c564SAndrew Turner bDone = m_gotExcepBytes;
595c120c564SAndrew Turner
596c120c564SAndrew Turner m_addrPktIsa = ocsd_isa_arm; // assume ARM, but then check
597c120c564SAndrew Turner if((currByte & 0x20) == 0x20) // bit 5 == 1'b1 - jazelle, bits 4 & 3 part of address.
598c120c564SAndrew Turner m_addrPktIsa = ocsd_isa_jazelle;
599c120c564SAndrew Turner else if((currByte & 0x30) == 0x10) // bit [5:4] == 2'b01 - thumb, bit 3 part of address.
600c120c564SAndrew Turner m_addrPktIsa = ocsd_isa_thumb2;
601c120c564SAndrew Turner }
602c120c564SAndrew Turner m_numAddrBytes++;
603c120c564SAndrew Turner }
604c120c564SAndrew Turner else if(!m_gotExcepBytes)
605c120c564SAndrew Turner {
606c120c564SAndrew Turner // excep byte is actually a WP update byte.
607c120c564SAndrew Turner m_excepAltISA = ((currByte & 0x40) == 0x40) ? 1 : 0;
608c120c564SAndrew Turner m_gotExcepBytes = true;
609c120c564SAndrew Turner m_numExcepBytes++;
610c120c564SAndrew Turner bDone = true;
611c120c564SAndrew Turner }
612c120c564SAndrew Turner }
613c120c564SAndrew Turner else
614c120c564SAndrew Turner bBytesAvail = false;
615c120c564SAndrew Turner }
616c120c564SAndrew Turner
617c120c564SAndrew Turner // analyse the bytes to create the packet
618c120c564SAndrew Turner if(bDone)
619c120c564SAndrew Turner {
620c120c564SAndrew Turner // ISA for the packet
621c120c564SAndrew Turner if(m_addrPktIsa == ocsd_isa_unknown) // unchanged by trace packet
622c120c564SAndrew Turner m_addrPktIsa = m_curr_packet.getISA(); // same as prev
623c120c564SAndrew Turner
624c120c564SAndrew Turner if(m_gotExcepBytes) // may adjust according to alt ISA in exception packet
625c120c564SAndrew Turner {
626c120c564SAndrew Turner if((m_addrPktIsa == ocsd_isa_tee) && (m_excepAltISA == 0))
627c120c564SAndrew Turner m_addrPktIsa = ocsd_isa_thumb2;
628c120c564SAndrew Turner else if((m_addrPktIsa == ocsd_isa_thumb2) && (m_excepAltISA == 1))
629c120c564SAndrew Turner m_addrPktIsa = ocsd_isa_tee;
630c120c564SAndrew Turner }
631c120c564SAndrew Turner m_curr_packet.UpdateISA(m_addrPktIsa); // mark ISA in packet (update changes current and prev to dectect an ISA change).
632c120c564SAndrew Turner
633c120c564SAndrew Turner uint8_t total_bits = 0;
634c120c564SAndrew Turner uint32_t addr_val = extractAddress(1,total_bits);
635c120c564SAndrew Turner m_curr_packet.UpdateAddress(addr_val,total_bits);
636c120c564SAndrew Turner m_process_state = SEND_PKT;
637c120c564SAndrew Turner }
638c120c564SAndrew Turner }
639c120c564SAndrew Turner
pktIgnore()640c120c564SAndrew Turner void TrcPktProcPtm::pktIgnore()
641c120c564SAndrew Turner {
642c120c564SAndrew Turner m_process_state = SEND_PKT; // no payload
643c120c564SAndrew Turner }
644c120c564SAndrew Turner
pktCtxtID()645c120c564SAndrew Turner void TrcPktProcPtm::pktCtxtID()
646c120c564SAndrew Turner {
647c120c564SAndrew Turner int pktIndex = m_currPacketData.size() - 1;
648c120c564SAndrew Turner
649c120c564SAndrew Turner // if at the header, determine how many more bytes we need.
650c120c564SAndrew Turner if(pktIndex == 0)
651c120c564SAndrew Turner {
652c120c564SAndrew Turner m_numCtxtIDBytes = m_config->CtxtIDBytes();
653c120c564SAndrew Turner m_gotCtxtIDBytes = 0;
654c120c564SAndrew Turner }
655c120c564SAndrew Turner
656c120c564SAndrew Turner // read the necessary ctxtID bytes from the stream
657c120c564SAndrew Turner bool bGotBytes = false, bytesAvail = true;
658c120c564SAndrew Turner uint32_t ctxtID = 0;
659c120c564SAndrew Turner
660c120c564SAndrew Turner bGotBytes = m_numCtxtIDBytes == m_gotCtxtIDBytes;
661c120c564SAndrew Turner while(!bGotBytes & bytesAvail)
662c120c564SAndrew Turner {
663c120c564SAndrew Turner bytesAvail = readByte();
664c120c564SAndrew Turner if(bytesAvail)
665c120c564SAndrew Turner m_gotCtxtIDBytes++;
666c120c564SAndrew Turner bGotBytes = m_numCtxtIDBytes == m_gotCtxtIDBytes;
667c120c564SAndrew Turner }
668c120c564SAndrew Turner
669c120c564SAndrew Turner if(bGotBytes)
670c120c564SAndrew Turner {
671c120c564SAndrew Turner if(m_numCtxtIDBytes)
672c120c564SAndrew Turner {
673c120c564SAndrew Turner extractCtxtID(1,ctxtID);
674c120c564SAndrew Turner }
675c120c564SAndrew Turner m_curr_packet.UpdateContextID(ctxtID);
676c120c564SAndrew Turner m_process_state = SEND_PKT;
677c120c564SAndrew Turner }
678c120c564SAndrew Turner }
679c120c564SAndrew Turner
pktVMID()680c120c564SAndrew Turner void TrcPktProcPtm::pktVMID()
681c120c564SAndrew Turner {
682c120c564SAndrew Turner uint8_t currByte;
683c120c564SAndrew Turner
684c120c564SAndrew Turner // just need a single payload byte...
685c120c564SAndrew Turner if(readByte(currByte))
686c120c564SAndrew Turner {
687c120c564SAndrew Turner m_curr_packet.UpdateVMID(currByte);
688c120c564SAndrew Turner m_process_state = SEND_PKT;
689c120c564SAndrew Turner }
690c120c564SAndrew Turner }
691c120c564SAndrew Turner
pktAtom()692c120c564SAndrew Turner void TrcPktProcPtm::pktAtom()
693c120c564SAndrew Turner {
694c120c564SAndrew Turner uint8_t pHdr = m_currPacketData[0];
695c120c564SAndrew Turner
696c120c564SAndrew Turner if(!m_config->enaCycleAcc())
697c120c564SAndrew Turner {
698c120c564SAndrew Turner m_curr_packet.SetAtomFromPHdr(pHdr);
699c120c564SAndrew Turner m_process_state = SEND_PKT;
700c120c564SAndrew Turner }
701c120c564SAndrew Turner else
702c120c564SAndrew Turner {
703c120c564SAndrew Turner bool bGotAllPktBytes = false, byteAvail = true;
704c120c564SAndrew Turner uint8_t currByte = 0; // cycle accurate tracing -> atom + cycle count
705c120c564SAndrew Turner
706c120c564SAndrew Turner if(!(pHdr & 0x40))
707c120c564SAndrew Turner {
708c120c564SAndrew Turner // only the header byte present
709c120c564SAndrew Turner bGotAllPktBytes = true;
710c120c564SAndrew Turner }
711c120c564SAndrew Turner else
712c120c564SAndrew Turner {
713c120c564SAndrew Turner // up to 4 additional bytes of count data.
714c120c564SAndrew Turner while(byteAvail && !bGotAllPktBytes)
715c120c564SAndrew Turner {
716c120c564SAndrew Turner if(readByte(currByte))
717c120c564SAndrew Turner {
718c120c564SAndrew Turner if(!(currByte & 0x80) || (m_currPacketData.size() == 5))
719c120c564SAndrew Turner bGotAllPktBytes = true;
720c120c564SAndrew Turner }
721c120c564SAndrew Turner else
722c120c564SAndrew Turner byteAvail = false;
723c120c564SAndrew Turner }
724c120c564SAndrew Turner }
725c120c564SAndrew Turner
726c120c564SAndrew Turner // we have all the bytes for a cycle accurate packet.
727c120c564SAndrew Turner if(bGotAllPktBytes)
728c120c564SAndrew Turner {
729c120c564SAndrew Turner uint32_t cycleCount = 0;
730c120c564SAndrew Turner extractCycleCount(0,cycleCount);
731c120c564SAndrew Turner m_curr_packet.SetCycleCount(cycleCount);
732c120c564SAndrew Turner m_curr_packet.SetCycleAccAtomFromPHdr(pHdr);
733c120c564SAndrew Turner m_process_state = SEND_PKT;
734c120c564SAndrew Turner }
735c120c564SAndrew Turner }
736c120c564SAndrew Turner }
737c120c564SAndrew Turner
pktTimeStamp()738c120c564SAndrew Turner void TrcPktProcPtm::pktTimeStamp()
739c120c564SAndrew Turner {
740c120c564SAndrew Turner uint8_t currByte = 0;
741c120c564SAndrew Turner int pktIndex = m_currPacketData.size() - 1;
742c120c564SAndrew Turner bool bGotBytes = false, byteAvail = true;
743c120c564SAndrew Turner
744c120c564SAndrew Turner if(pktIndex == 0)
745c120c564SAndrew Turner {
746c120c564SAndrew Turner m_gotTSBytes = false;
747c120c564SAndrew Turner m_needCycleCount = m_config->enaCycleAcc();
748c120c564SAndrew Turner m_gotCCBytes = 0;
749c120c564SAndrew Turner
750c120c564SAndrew Turner // max byte buffer size for full ts packet
751c120c564SAndrew Turner m_tsByteMax = m_config->TSPkt64() ? 10 : 8;
752c120c564SAndrew Turner }
753c120c564SAndrew Turner
754c120c564SAndrew Turner while(byteAvail && !bGotBytes)
755c120c564SAndrew Turner {
756c120c564SAndrew Turner if(readByte(currByte))
757c120c564SAndrew Turner {
758c120c564SAndrew Turner if(!m_gotTSBytes)
759c120c564SAndrew Turner {
760c120c564SAndrew Turner if(((currByte & 0x80) == 0) || (m_currPacketData.size() == (unsigned)m_tsByteMax))
761c120c564SAndrew Turner {
762c120c564SAndrew Turner m_gotTSBytes = true;
763c120c564SAndrew Turner if(!m_needCycleCount)
764c120c564SAndrew Turner bGotBytes = true;
765c120c564SAndrew Turner }
766c120c564SAndrew Turner }
767c120c564SAndrew Turner else
768c120c564SAndrew Turner {
769c120c564SAndrew Turner uint8_t cc_cont_mask = 0x80;
770c120c564SAndrew Turner // got TS bytes, collect cycle count
771c120c564SAndrew Turner if(m_gotCCBytes == 0)
772c120c564SAndrew Turner cc_cont_mask = 0x40;
773c120c564SAndrew Turner if((currByte & cc_cont_mask) == 0)
774c120c564SAndrew Turner bGotBytes = true;
775c120c564SAndrew Turner m_gotCCBytes++;
776c120c564SAndrew Turner if(m_gotCCBytes == 5)
777c120c564SAndrew Turner bGotBytes = true;
778c120c564SAndrew Turner }
779c120c564SAndrew Turner }
780c120c564SAndrew Turner else
781c120c564SAndrew Turner byteAvail = false;
782c120c564SAndrew Turner }
783c120c564SAndrew Turner
784c120c564SAndrew Turner if(bGotBytes)
785c120c564SAndrew Turner {
786c120c564SAndrew Turner uint64_t tsVal = 0;
787c120c564SAndrew Turner uint32_t cycleCount = 0;
788c120c564SAndrew Turner uint8_t tsUpdateBits = 0;
789c120c564SAndrew Turner int ts_end_idx = extractTS(tsVal,tsUpdateBits);
790c120c564SAndrew Turner if(m_needCycleCount)
791c120c564SAndrew Turner {
792c120c564SAndrew Turner extractCycleCount(ts_end_idx,cycleCount);
793c120c564SAndrew Turner m_curr_packet.SetCycleCount(cycleCount);
794c120c564SAndrew Turner }
795c120c564SAndrew Turner m_curr_packet.UpdateTimestamp(tsVal,tsUpdateBits);
796c120c564SAndrew Turner m_process_state = SEND_PKT;
797c120c564SAndrew Turner }
798c120c564SAndrew Turner }
799c120c564SAndrew Turner
pktExceptionRet()800c120c564SAndrew Turner void TrcPktProcPtm::pktExceptionRet()
801c120c564SAndrew Turner {
802c120c564SAndrew Turner m_process_state = SEND_PKT; // no payload
803c120c564SAndrew Turner }
804c120c564SAndrew Turner
pktBranchAddr()805c120c564SAndrew Turner void TrcPktProcPtm::pktBranchAddr()
806c120c564SAndrew Turner {
807c120c564SAndrew Turner uint8_t currByte = m_currPacketData[0];
808c120c564SAndrew Turner bool bDone = false;
809c120c564SAndrew Turner bool bBytesAvail = true;
810c120c564SAndrew Turner int byteIdx = 0;
811c120c564SAndrew Turner
812c120c564SAndrew Turner if(m_currPacketData.size() == 1)
813c120c564SAndrew Turner {
814c120c564SAndrew Turner m_gotAddrBytes = false; // flag to indicate got all needed address bytes
815c120c564SAndrew Turner m_numAddrBytes = 1; // number of address bytes so far
816c120c564SAndrew Turner
817c120c564SAndrew Turner m_needCycleCount = m_config->enaCycleAcc(); // check if we have a cycle count
818c120c564SAndrew Turner m_gotCCBytes = 0; // number of cc bytes read in so far.
819c120c564SAndrew Turner
820c120c564SAndrew Turner m_gotExcepBytes = false; // mark as not got all required exception bytes thus far
821c120c564SAndrew Turner m_numExcepBytes = 0; // 0 read in
822c120c564SAndrew Turner
823c120c564SAndrew Turner m_addrPktIsa = ocsd_isa_unknown; // not set by this packet as yet
824c120c564SAndrew Turner
825c120c564SAndrew Turner // header is also 1st address byte
826c120c564SAndrew Turner if((currByte & 0x80) == 0) // could be single byte packet
827c120c564SAndrew Turner {
828c120c564SAndrew Turner m_gotAddrBytes = true;
829c120c564SAndrew Turner if(!m_needCycleCount)
830c120c564SAndrew Turner bDone = true; // all done if no cycle count
831c120c564SAndrew Turner m_gotExcepBytes = true; // cannot have exception bytes following single byte packet
832c120c564SAndrew Turner }
833c120c564SAndrew Turner
834c120c564SAndrew Turner }
835c120c564SAndrew Turner
836c120c564SAndrew Turner // collect all the bytes needed
837c120c564SAndrew Turner while(!bDone && bBytesAvail)
838c120c564SAndrew Turner {
839c120c564SAndrew Turner if(readByte(currByte))
840c120c564SAndrew Turner {
841c120c564SAndrew Turner byteIdx = m_currPacketData.size() - 1;
842c120c564SAndrew Turner if(!m_gotAddrBytes)
843c120c564SAndrew Turner {
844c120c564SAndrew Turner if(byteIdx < 4)
845c120c564SAndrew Turner {
846c120c564SAndrew Turner // address bytes 2 - 4;
847c120c564SAndrew Turner // ISA stays the same
848c120c564SAndrew Turner if((currByte & 0x80) == 0x00)
849c120c564SAndrew Turner {
850c120c564SAndrew Turner // no further bytes
851c120c564SAndrew Turner if((currByte & 0x40) == 0x00)
852c120c564SAndrew Turner m_gotExcepBytes = true; // no exception bytes - mark as done
853c120c564SAndrew Turner m_gotAddrBytes = true;
854c120c564SAndrew Turner bDone = m_gotExcepBytes && !m_needCycleCount;
855c120c564SAndrew Turner }
856c120c564SAndrew Turner }
857c120c564SAndrew Turner else
858c120c564SAndrew Turner {
859c120c564SAndrew Turner // 5th address byte - determine ISA from this.
860c120c564SAndrew Turner if((currByte & 0x40) == 0x00)
861c120c564SAndrew Turner m_gotExcepBytes = true; // no exception bytes - mark as done
862c120c564SAndrew Turner m_gotAddrBytes = true;
863c120c564SAndrew Turner bDone = m_gotExcepBytes && !m_needCycleCount;
864c120c564SAndrew Turner
865c120c564SAndrew Turner m_addrPktIsa = ocsd_isa_arm; // assume ARM, but then check
866c120c564SAndrew Turner if((currByte & 0x20) == 0x20) // bit 5 == 1'b1 - jazelle, bits 4 & 3 part of address.
867c120c564SAndrew Turner m_addrPktIsa = ocsd_isa_jazelle;
868c120c564SAndrew Turner else if((currByte & 0x30) == 0x10) // bit [5:4] == 2'b01 - thumb, bit 3 part of address.
869c120c564SAndrew Turner m_addrPktIsa = ocsd_isa_thumb2;
870c120c564SAndrew Turner }
871c120c564SAndrew Turner m_numAddrBytes++;
872c120c564SAndrew Turner }
873c120c564SAndrew Turner else if(!m_gotExcepBytes)
874c120c564SAndrew Turner {
875c120c564SAndrew Turner // may need exception bytes
876c120c564SAndrew Turner if(m_numExcepBytes == 0)
877c120c564SAndrew Turner {
878c120c564SAndrew Turner if((currByte & 0x80) == 0x00)
879c120c564SAndrew Turner m_gotExcepBytes = true;
880c120c564SAndrew Turner m_excepAltISA = ((currByte & 0x40) == 0x40) ? 1 : 0;
881c120c564SAndrew Turner }
882c120c564SAndrew Turner else
883c120c564SAndrew Turner m_gotExcepBytes = true;
884c120c564SAndrew Turner m_numExcepBytes++;
885c120c564SAndrew Turner
886c120c564SAndrew Turner if(m_gotExcepBytes && !m_needCycleCount)
887c120c564SAndrew Turner bDone = true;
888c120c564SAndrew Turner
889c120c564SAndrew Turner }
890c120c564SAndrew Turner else if(m_needCycleCount)
891c120c564SAndrew Turner {
892c120c564SAndrew Turner // not done after exception bytes, collect cycle count
893c120c564SAndrew Turner if(m_gotCCBytes == 0)
894c120c564SAndrew Turner {
895c120c564SAndrew Turner bDone = ((currByte & 0x40) == 0x00 );
896c120c564SAndrew Turner }
897c120c564SAndrew Turner else
898c120c564SAndrew Turner {
899c120c564SAndrew Turner // done if no more or 5th byte
900c120c564SAndrew Turner bDone = (((currByte & 0x80) == 0x00 ) || (m_gotCCBytes == 4));
901c120c564SAndrew Turner }
902c120c564SAndrew Turner m_gotCCBytes++;
903c120c564SAndrew Turner }
904c120c564SAndrew Turner else
905c120c564SAndrew Turner // this should never be reached.
906c120c564SAndrew Turner throwMalformedPacketErr("sequencing error analysing branch packet");
907c120c564SAndrew Turner }
908c120c564SAndrew Turner else
909c120c564SAndrew Turner bBytesAvail = false;
910c120c564SAndrew Turner }
911c120c564SAndrew Turner
912c120c564SAndrew Turner // analyse the bytes to create the packet
913c120c564SAndrew Turner if(bDone)
914c120c564SAndrew Turner {
915c120c564SAndrew Turner // ISA for the packet
916c120c564SAndrew Turner if(m_addrPktIsa == ocsd_isa_unknown) // unchanged by trace packet
917c120c564SAndrew Turner m_addrPktIsa = m_curr_packet.getISA(); // same as prev
918c120c564SAndrew Turner
919c120c564SAndrew Turner if(m_gotExcepBytes) // may adjust according to alt ISA in exception packet
920c120c564SAndrew Turner {
921c120c564SAndrew Turner if((m_addrPktIsa == ocsd_isa_tee) && (m_excepAltISA == 0))
922c120c564SAndrew Turner m_addrPktIsa = ocsd_isa_thumb2;
923c120c564SAndrew Turner else if((m_addrPktIsa == ocsd_isa_thumb2) && (m_excepAltISA == 1))
924c120c564SAndrew Turner m_addrPktIsa = ocsd_isa_tee;
925c120c564SAndrew Turner }
926c120c564SAndrew Turner m_curr_packet.UpdateISA(m_addrPktIsa); // mark ISA in packet (update changes current and prev to dectect an ISA change).
927c120c564SAndrew Turner
928c120c564SAndrew Turner
929c120c564SAndrew Turner
930c120c564SAndrew Turner // we know the ISA, we can correctly interpret the address.
931c120c564SAndrew Turner uint8_t total_bits = 0;
932c120c564SAndrew Turner uint32_t addr_val = extractAddress(0,total_bits);
933c120c564SAndrew Turner m_curr_packet.UpdateAddress(addr_val,total_bits);
934c120c564SAndrew Turner
935c120c564SAndrew Turner if(m_numExcepBytes > 0)
936c120c564SAndrew Turner {
937c120c564SAndrew Turner uint8_t E1 = m_currPacketData[m_numAddrBytes];
938c120c564SAndrew Turner uint16_t ENum = (E1 >> 1) & 0xF;
939c120c564SAndrew Turner ocsd_armv7_exception excep = Excp_Reserved;
940c120c564SAndrew Turner
941c120c564SAndrew Turner m_curr_packet.UpdateNS(E1 & 0x1);
942c120c564SAndrew Turner if(m_numExcepBytes > 1)
943c120c564SAndrew Turner {
944c120c564SAndrew Turner uint8_t E2 = m_currPacketData[m_numAddrBytes+1];
945c120c564SAndrew Turner m_curr_packet.UpdateHyp((E2 >> 5) & 0x1);
946c120c564SAndrew Turner ENum |= ((uint16_t)(E2 & 0x1F) << 4);
947c120c564SAndrew Turner }
948c120c564SAndrew Turner
949c120c564SAndrew Turner if(ENum <= 0xF)
950c120c564SAndrew Turner {
951c120c564SAndrew Turner static ocsd_armv7_exception v7ARExceptions[16] = {
952c120c564SAndrew Turner Excp_NoException, Excp_DebugHalt, Excp_SMC, Excp_Hyp,
953c120c564SAndrew Turner Excp_AsyncDAbort, Excp_ThumbEECheckFail, Excp_Reserved, Excp_Reserved,
954c120c564SAndrew Turner Excp_Reset, Excp_Undef, Excp_SVC, Excp_PrefAbort,
955c120c564SAndrew Turner Excp_SyncDataAbort, Excp_Generic, Excp_IRQ, Excp_FIQ
956c120c564SAndrew Turner };
957c120c564SAndrew Turner excep = v7ARExceptions[ENum];
958c120c564SAndrew Turner }
959c120c564SAndrew Turner m_curr_packet.SetException(excep,ENum);
960c120c564SAndrew Turner }
961c120c564SAndrew Turner
962c120c564SAndrew Turner if(m_needCycleCount)
963c120c564SAndrew Turner {
964c120c564SAndrew Turner int countIdx = m_numAddrBytes + m_numExcepBytes;
965c120c564SAndrew Turner uint32_t cycleCount = 0;
966c120c564SAndrew Turner extractCycleCount(countIdx,cycleCount);
967c120c564SAndrew Turner m_curr_packet.SetCycleCount(cycleCount);
968c120c564SAndrew Turner }
969c120c564SAndrew Turner m_process_state = SEND_PKT;
970c120c564SAndrew Turner }
971c120c564SAndrew Turner }
972c120c564SAndrew Turner
pktReserved()973c120c564SAndrew Turner void TrcPktProcPtm::pktReserved()
974c120c564SAndrew Turner {
975c120c564SAndrew Turner m_process_state = SEND_PKT; // no payload
976c120c564SAndrew Turner }
977c120c564SAndrew Turner
extractCtxtID(int idx,uint32_t & ctxtID)978c120c564SAndrew Turner void TrcPktProcPtm::extractCtxtID(int idx, uint32_t &ctxtID)
979c120c564SAndrew Turner {
980c120c564SAndrew Turner ctxtID = 0;
981c120c564SAndrew Turner int shift = 0;
982c120c564SAndrew Turner for(int i=0; i < m_numCtxtIDBytes; i++)
983c120c564SAndrew Turner {
984c120c564SAndrew Turner if((size_t)idx+i >= m_currPacketData.size())
985c120c564SAndrew Turner throwMalformedPacketErr("Insufficient packet bytes for Context ID value.");
986c120c564SAndrew Turner ctxtID |= ((uint32_t)m_currPacketData[idx+i]) << shift;
987c120c564SAndrew Turner shift+=8;
988c120c564SAndrew Turner }
989c120c564SAndrew Turner }
990c120c564SAndrew Turner
extractCycleCount(int offset,uint32_t & cycleCount)991c120c564SAndrew Turner void TrcPktProcPtm::extractCycleCount(int offset, uint32_t &cycleCount)
992c120c564SAndrew Turner {
993c120c564SAndrew Turner bool bCont = true;
994c120c564SAndrew Turner cycleCount = 0;
995c120c564SAndrew Turner int by_idx = 0;
996c120c564SAndrew Turner uint8_t currByte;
997c120c564SAndrew Turner int shift = 4;
998c120c564SAndrew Turner
999c120c564SAndrew Turner while(bCont)
1000c120c564SAndrew Turner {
1001c120c564SAndrew Turner if((size_t)by_idx+offset >= m_currPacketData.size())
1002c120c564SAndrew Turner throwMalformedPacketErr("Insufficient packet bytes for Cycle Count value.");
1003c120c564SAndrew Turner
1004c120c564SAndrew Turner currByte = m_currPacketData[offset+by_idx];
1005c120c564SAndrew Turner if(by_idx == 0)
1006c120c564SAndrew Turner {
1007c120c564SAndrew Turner bCont = (currByte & 0x40) != 0;
1008c120c564SAndrew Turner cycleCount = (currByte >> 2) & 0xF;
1009c120c564SAndrew Turner }
1010c120c564SAndrew Turner else
1011c120c564SAndrew Turner {
1012c120c564SAndrew Turner
1013c120c564SAndrew Turner bCont = (currByte & 0x80) != 0;
1014c120c564SAndrew Turner if(by_idx == 4)
1015c120c564SAndrew Turner bCont = false;
1016c120c564SAndrew Turner cycleCount |= (((uint32_t)(currByte & 0x7F)) << shift);
1017c120c564SAndrew Turner shift += 7;
1018c120c564SAndrew Turner }
1019c120c564SAndrew Turner by_idx++;
1020c120c564SAndrew Turner }
1021c120c564SAndrew Turner }
1022c120c564SAndrew Turner
extractTS(uint64_t & tsVal,uint8_t & tsUpdateBits)1023c120c564SAndrew Turner int TrcPktProcPtm::extractTS(uint64_t &tsVal,uint8_t &tsUpdateBits)
1024c120c564SAndrew Turner {
1025c120c564SAndrew Turner bool bCont = true;
1026c120c564SAndrew Turner int tsIdx = 1; // start index;
1027c120c564SAndrew Turner uint8_t byteVal;
1028c120c564SAndrew Turner bool b64BitVal = m_config->TSPkt64();
1029c120c564SAndrew Turner int shift = 0;
1030c120c564SAndrew Turner
1031c120c564SAndrew Turner tsVal = 0;
1032c120c564SAndrew Turner tsUpdateBits = 0;
1033c120c564SAndrew Turner
1034c120c564SAndrew Turner while(bCont)
1035c120c564SAndrew Turner {
1036c120c564SAndrew Turner if((size_t)tsIdx >= m_currPacketData.size())
1037c120c564SAndrew Turner throwMalformedPacketErr("Insufficient packet bytes for Timestamp value.");
1038c120c564SAndrew Turner
1039c120c564SAndrew Turner byteVal = m_currPacketData[tsIdx];
1040c120c564SAndrew Turner
1041c120c564SAndrew Turner if(b64BitVal)
1042c120c564SAndrew Turner {
1043c120c564SAndrew Turner if(tsIdx < 9)
1044c120c564SAndrew Turner {
1045c120c564SAndrew Turner bCont = ((byteVal & 0x80) == 0x80);
1046c120c564SAndrew Turner byteVal &= 0x7F;
1047c120c564SAndrew Turner tsUpdateBits += 7;
1048c120c564SAndrew Turner }
1049c120c564SAndrew Turner else
1050c120c564SAndrew Turner {
1051c120c564SAndrew Turner bCont = false;
1052c120c564SAndrew Turner tsUpdateBits += 8;
1053c120c564SAndrew Turner }
1054c120c564SAndrew Turner }
1055c120c564SAndrew Turner else
1056c120c564SAndrew Turner {
1057c120c564SAndrew Turner if(tsIdx < 7)
1058c120c564SAndrew Turner {
1059c120c564SAndrew Turner bCont = ((byteVal & 0x80) == 0x80);
1060c120c564SAndrew Turner byteVal &= 0x7F;
1061c120c564SAndrew Turner tsUpdateBits += 7;
1062c120c564SAndrew Turner }
1063c120c564SAndrew Turner else
1064c120c564SAndrew Turner {
1065c120c564SAndrew Turner byteVal &=0x3F;
1066c120c564SAndrew Turner bCont = false;
1067c120c564SAndrew Turner tsUpdateBits += 6;
1068c120c564SAndrew Turner }
1069c120c564SAndrew Turner }
1070c120c564SAndrew Turner tsVal |= (((uint64_t)byteVal) << shift);
1071c120c564SAndrew Turner tsIdx++;
1072c120c564SAndrew Turner shift += 7;
1073c120c564SAndrew Turner }
1074c120c564SAndrew Turner return tsIdx; // return next byte index in packet.
1075c120c564SAndrew Turner }
1076c120c564SAndrew Turner
extractAddress(const int offset,uint8_t & total_bits)1077c120c564SAndrew Turner uint32_t TrcPktProcPtm::extractAddress(const int offset, uint8_t &total_bits)
1078c120c564SAndrew Turner {
1079c120c564SAndrew Turner // we know the ISA, we can correctly interpret the address.
1080c120c564SAndrew Turner uint32_t addr_val = 0;
1081c120c564SAndrew Turner uint8_t mask = 0x7E; // first byte mask (always);
1082c120c564SAndrew Turner uint8_t num_bits = 0x7; // number of bits in the 1st byte (thumb);
1083c120c564SAndrew Turner int shift = 0;
1084c120c564SAndrew Turner int next_shift = 0;
1085c120c564SAndrew Turner
1086c120c564SAndrew Turner total_bits = 0;
1087c120c564SAndrew Turner
1088c120c564SAndrew Turner for(int i = 0; i < m_numAddrBytes; i++)
1089c120c564SAndrew Turner {
1090c120c564SAndrew Turner if(i == 4)
1091c120c564SAndrew Turner {
1092c120c564SAndrew Turner // 5th byte mask
1093c120c564SAndrew Turner mask = 0x0f; // thumb mask;
1094c120c564SAndrew Turner num_bits = 4;
1095c120c564SAndrew Turner if(m_addrPktIsa == ocsd_isa_jazelle)
1096c120c564SAndrew Turner {
1097c120c564SAndrew Turner mask = 0x1F;
1098c120c564SAndrew Turner num_bits = 5;
1099c120c564SAndrew Turner }
1100c120c564SAndrew Turner else if(m_addrPktIsa == ocsd_isa_arm)
1101c120c564SAndrew Turner {
1102c120c564SAndrew Turner mask = 0x07;
1103c120c564SAndrew Turner num_bits = 3;
1104c120c564SAndrew Turner }
1105c120c564SAndrew Turner }
1106c120c564SAndrew Turner else if(i > 0)
1107c120c564SAndrew Turner {
1108c120c564SAndrew Turner mask = 0x7F;
1109c120c564SAndrew Turner num_bits = 7;
1110c120c564SAndrew Turner // check for last byte but not 1st or 5th byte mask
1111c120c564SAndrew Turner if(i == m_numAddrBytes-1)
1112c120c564SAndrew Turner {
1113c120c564SAndrew Turner mask = 0x3F;
1114c120c564SAndrew Turner num_bits = 6;
1115c120c564SAndrew Turner }
1116c120c564SAndrew Turner }
1117c120c564SAndrew Turner
1118c120c564SAndrew Turner // extract data
1119c120c564SAndrew Turner shift = next_shift;
1120c120c564SAndrew Turner addr_val |= ((uint32_t)(m_currPacketData[i+offset] & mask) << shift);
1121c120c564SAndrew Turner total_bits += num_bits;
1122c120c564SAndrew Turner
1123c120c564SAndrew Turner // how much we shift the next value
1124c120c564SAndrew Turner if(i == 0)
1125c120c564SAndrew Turner {
1126c120c564SAndrew Turner if(m_addrPktIsa == ocsd_isa_jazelle)
1127c120c564SAndrew Turner {
1128c120c564SAndrew Turner addr_val >>= 1;
1129c120c564SAndrew Turner next_shift = 6;
1130c120c564SAndrew Turner total_bits--; // adjust bits for jazelle offset
1131c120c564SAndrew Turner }
1132c120c564SAndrew Turner else
1133c120c564SAndrew Turner {
1134c120c564SAndrew Turner next_shift = 7;
1135c120c564SAndrew Turner }
1136c120c564SAndrew Turner }
1137c120c564SAndrew Turner else
1138c120c564SAndrew Turner {
1139c120c564SAndrew Turner next_shift += 7;
1140c120c564SAndrew Turner }
1141c120c564SAndrew Turner }
1142c120c564SAndrew Turner
1143c120c564SAndrew Turner if(m_addrPktIsa == ocsd_isa_arm)
1144c120c564SAndrew Turner {
1145c120c564SAndrew Turner addr_val <<= 1; // shift one extra bit for ARM address alignment.
1146c120c564SAndrew Turner total_bits++;
1147c120c564SAndrew Turner }
1148c120c564SAndrew Turner return addr_val;
1149c120c564SAndrew Turner }
1150c120c564SAndrew Turner
1151c120c564SAndrew Turner
BuildIPacketTable()1152c120c564SAndrew Turner void TrcPktProcPtm::BuildIPacketTable()
1153c120c564SAndrew Turner {
1154c120c564SAndrew Turner // initialise all to branch, atom or reserved packet header
1155c120c564SAndrew Turner for(unsigned i = 0; i < 256; i++)
1156c120c564SAndrew Turner {
1157c120c564SAndrew Turner // branch address packets all end in 8'bxxxxxxx1
1158c120c564SAndrew Turner if((i & 0x01) == 0x01)
1159c120c564SAndrew Turner {
1160c120c564SAndrew Turner m_i_table[i].pkt_type = PTM_PKT_BRANCH_ADDRESS;
1161c120c564SAndrew Turner m_i_table[i].pptkFn = &TrcPktProcPtm::pktBranchAddr;
1162c120c564SAndrew Turner }
1163c120c564SAndrew Turner // atom packets are 8'b1xxxxxx0
1164c120c564SAndrew Turner else if((i & 0x81) == 0x80)
1165c120c564SAndrew Turner {
1166c120c564SAndrew Turner m_i_table[i].pkt_type = PTM_PKT_ATOM;
1167c120c564SAndrew Turner m_i_table[i].pptkFn = &TrcPktProcPtm::pktAtom;
1168c120c564SAndrew Turner }
1169c120c564SAndrew Turner else
1170c120c564SAndrew Turner {
1171c120c564SAndrew Turner // set all the others to reserved for now
1172c120c564SAndrew Turner m_i_table[i].pkt_type = PTM_PKT_RESERVED;
1173c120c564SAndrew Turner m_i_table[i].pptkFn = &TrcPktProcPtm::pktReserved;
1174c120c564SAndrew Turner }
1175c120c564SAndrew Turner }
1176c120c564SAndrew Turner
1177c120c564SAndrew Turner // pick out the other packet types by individual codes.
1178c120c564SAndrew Turner
1179c120c564SAndrew Turner // A-sync 8'b00000000
1180c120c564SAndrew Turner m_i_table[0x00].pkt_type = PTM_PKT_A_SYNC;
1181c120c564SAndrew Turner m_i_table[0x00].pptkFn = &TrcPktProcPtm::pktASync;
1182c120c564SAndrew Turner
1183c120c564SAndrew Turner // I-sync 8'b00001000
1184c120c564SAndrew Turner m_i_table[0x08].pkt_type = PTM_PKT_I_SYNC;
1185c120c564SAndrew Turner m_i_table[0x08].pptkFn = &TrcPktProcPtm::pktISync;
1186c120c564SAndrew Turner
1187c120c564SAndrew Turner // waypoint update 8'b01110010
1188c120c564SAndrew Turner m_i_table[0x72].pkt_type = PTM_PKT_WPOINT_UPDATE;
1189c120c564SAndrew Turner m_i_table[0x72].pptkFn = &TrcPktProcPtm::pktWPointUpdate;
1190c120c564SAndrew Turner
1191c120c564SAndrew Turner // trigger 8'b00001100
1192c120c564SAndrew Turner m_i_table[0x0C].pkt_type = PTM_PKT_TRIGGER;
1193c120c564SAndrew Turner m_i_table[0x0C].pptkFn = &TrcPktProcPtm::pktTrigger;
1194c120c564SAndrew Turner
1195c120c564SAndrew Turner // context ID 8'b01101110
1196c120c564SAndrew Turner m_i_table[0x6E].pkt_type = PTM_PKT_CONTEXT_ID;
1197c120c564SAndrew Turner m_i_table[0x6E].pptkFn = &TrcPktProcPtm::pktCtxtID;
1198c120c564SAndrew Turner
1199c120c564SAndrew Turner // VMID 8'b00111100
1200c120c564SAndrew Turner m_i_table[0x3C].pkt_type = PTM_PKT_VMID;
1201c120c564SAndrew Turner m_i_table[0x3C].pptkFn = &TrcPktProcPtm::pktVMID;
1202c120c564SAndrew Turner
1203c120c564SAndrew Turner // Timestamp 8'b01000x10
1204c120c564SAndrew Turner m_i_table[0x42].pkt_type = PTM_PKT_TIMESTAMP;
1205c120c564SAndrew Turner m_i_table[0x42].pptkFn = &TrcPktProcPtm::pktTimeStamp;
1206c120c564SAndrew Turner m_i_table[0x46].pkt_type = PTM_PKT_TIMESTAMP;
1207c120c564SAndrew Turner m_i_table[0x46].pptkFn = &TrcPktProcPtm::pktTimeStamp;
1208c120c564SAndrew Turner
1209c120c564SAndrew Turner // Exception return 8'b01110110
1210c120c564SAndrew Turner m_i_table[0x76].pkt_type = PTM_PKT_EXCEPTION_RET;
1211c120c564SAndrew Turner m_i_table[0x76].pptkFn = &TrcPktProcPtm::pktExceptionRet;
1212c120c564SAndrew Turner
1213c120c564SAndrew Turner // Ignore 8'b01100110
1214c120c564SAndrew Turner m_i_table[0x66].pkt_type = PTM_PKT_IGNORE;
1215c120c564SAndrew Turner m_i_table[0x66].pptkFn = &TrcPktProcPtm::pktIgnore;
1216c120c564SAndrew Turner }
1217c120c564SAndrew Turner
1218c120c564SAndrew Turner /* End of File trc_pkt_proc_ptm.cpp */
1219