?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MSWSP: append to proto column instaed of overwriting it
[wireshark-wip.git] / plugins / ethercat / packet-ethercat-datagram.c
blob9299f4741798425389759634fc11ea1cf97ee609
1 /* packet-ethercat-datagram.c
2 * Routines for ethercat packet disassembly
3 *
4 * $Id$
5 *
6 * Copyright (c) 2007 by Beckhoff Automation GmbH
7 *
8 * Wireshark - Network traffic analyzer
9 * By Gerald Combs <gerald@wireshark.org>
10 * Copyright 1998 Gerald Combs
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version 2
15 * of the License, or (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
25 */
26
27 /* Include files */
28
29 #include "config.h"
30
31 #include <glib.h>
32
33 #include <epan/packet.h>
34
35 #include "packet-ethercat-datagram.h"
36 #include "packet-ecatmb.h"
37
38 static heur_dissector_list_t heur_subdissector_list;
39 static dissector_handle_t ecat_mailbox_handle;
40
41 /* Define the EtherCAT proto */
42 static int proto_ecat_datagram = -1;
43
44 /* Define the tree for EtherCAT */
45 static int ett_ecat = -1;
46 static int ett_ecat_header = -1;
47 static int ett_ecat_syncman = -1;
48 static int ett_ecat_syncflag = -1;
49 static int ett_ecat_fmmu = -1;
50 static int ett_ecat_fmmu_type = -1;
51 static int ett_ecat_fmmu_active = -1;
52 static int ett_ecat_dc = -1;
53 static int ett_ecat_length = -1;
54 static int ett_ecat_padding = -1;
55 static int ett_ecat_datagram_subtree = -1;
56
57 static int hf_ecat_sub;
58 static int hf_ecat_sub_data[10] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
59 static int hf_ecat_sub_cmd[10] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
60 static int hf_ecat_sub_idx[10] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
61 static int hf_ecat_sub_cnt[10] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
62 static int hf_ecat_sub_ado[10] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
63 static int hf_ecat_sub_adp[10] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
64 static int hf_ecat_sub_lad[10] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
65
66 /* static int hf_ecat_header = -1; */
67 static int hf_ecat_data = -1;
68 static int hf_ecat_cnt = -1;
69 static int hf_ecat_cmd = -1;
70 static int hf_ecat_idx = -1;
71 static int hf_ecat_adp = -1;
72 static int hf_ecat_ado = -1;
73 static int hf_ecat_lad = -1;
74 /* static int hf_ecat_len = -1; */
75 static int hf_ecat_int = -1;
76 static int hf_ecat_syncman = -1;
77 static int hf_ecat_syncman_start = -1;
78 static int hf_ecat_syncman_len = -1;
79 static int hf_ecat_syncman_flags = -1;
80 static int hf_ecat_syncman_flag0 = -1;
81 static int hf_ecat_syncman_flag1 = -1;
82 static int hf_ecat_syncman_flag2 = -1;
83 static int hf_ecat_syncman_flag4 = -1;
84 static int hf_ecat_syncman_flag5 = -1;
85 static int hf_ecat_syncman_flag8 = -1;
86 static int hf_ecat_syncman_flag9 = -1;
87 static int hf_ecat_syncman_flag10 = -1;
88 static int hf_ecat_syncman_flag11 = -1;
89 static int hf_ecat_syncman_flag12 = -1;
90 static int hf_ecat_syncman_flag13 = -1;
91 static int hf_ecat_syncman_flag16 = -1;
92 static int hf_ecat_fmmu = -1;
93 static int hf_ecat_fmmu_lstart = -1;
94 static int hf_ecat_fmmu_llen = -1;
95 static int hf_ecat_fmmu_lstartbit = -1;
96 static int hf_ecat_fmmu_lendbit = -1;
97 static int hf_ecat_fmmu_pstart = -1;
98 static int hf_ecat_fmmu_pstartbit = -1;
99 static int hf_ecat_fmmu_type = -1;
100 static int hf_ecat_fmmu_typeread = -1;
101 static int hf_ecat_fmmu_typewrite = -1;
102 static int hf_ecat_fmmu_active = -1;
103 static int hf_ecat_fmmu_active0 = -1;
104
105 static int hf_ecat_sub_dc_diff_da[10] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
106 static int hf_ecat_sub_dc_diff_bd[10] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
107 static int hf_ecat_sub_dc_diff_cb[10] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
108 static int hf_ecat_sub_dc_diff_cd[10] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
109 static int hf_ecat_sub_dc_diff_ba[10] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
110 static int hf_ecat_sub_dc_diff_ca[10] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
111
112 static int hf_ecat_dc_diff_da = -1;
113 static int hf_ecat_dc_diff_bd = -1;
114 static int hf_ecat_dc_diff_cb = -1;
115 static int hf_ecat_dc_diff_cd = -1;
116 static int hf_ecat_dc_diff_ba = -1;
117 static int hf_ecat_dc_diff_ca = -1;
118
119 static int hf_ecat_length_len = -1;
120 static int hf_ecat_length_r = -1;
121 static int hf_ecat_length_c = -1;
122 static int hf_ecat_length_m = -1;
123
124 static int hf_ecat_padding = -1;
125
126 static const value_string EcCmdShort[] =
127 {
128 { 0, "NOP" },
129 { 1, "APRD" },
130 { 2, "APWR" },
131 { 3, "APRW" },
132 { 4, "FPRD" },
133 { 5, "FPWR" },
134 { 6, "FPRW" },
135 { 7, "BRD" },
136 { 8, "BWR" },
137 { 9, "BRW" },
138 { 10, "LRD" },
139 { 11, "LWR" },
140 { 12, "LRW" },
141 { 13, "ARMW" },
142 { 14, "FRMW" },
143 { 255, "EXT" },
144 { 0, NULL }
145 };
146
147 static const value_string EcCmdLong[] =
148 {
149 { 0, "No operation" },
150 { 1, "Auto Increment Physical Read" },
151 { 2, "Auto Increment Physical Write" },
152 { 3, "Auto Increment Physical ReadWrite" },
153 { 4, "Configured address Physical Read" },
154 { 5, "Configured address Physical Write" },
155 { 6, "Configured address Physical ReadWrite" },
156 { 7, "Broadcast Read" },
157 { 8, "Broadcast Write" },
158 { 9, "Broadcast ReadWrite" },
159 { 10, "Logical Read" },
160 { 11, "Logical Write" },
161 { 12, "Logical ReadWrite" },
162 { 13, "Auto Increment Physical Read Multiple Write" },
163 { 14, "Configured Address Physical Read Multiple Write" },
164 { 255, "EXT" },
165 { 0, NULL }
166 };
167
168 static const value_string ecat_subframe_reserved_vals[] =
169 {
170 { 0, "Valid"},
171 { 0, NULL}
172 };
173
174 static const value_string ecat_subframe_circulating_vals[] =
175 {
176 { 0, "Frame is not circulating" },
177 { 1, "Frame has circulated once" },
178 { 0, NULL }
179 };
180
181 static const value_string ecat_subframe_more_vals[] =
182 {
183 { 0, "Last EtherCAT datagram"},
184 { 1, "More EtherCAT datagrams will follow"},
185 { 0, NULL}
186 };
187
188 static const true_false_string tfs_ecat_fmmu_typeread =
189 {
190 "Read in use", "Read ignore"
191 };
192
193 static const true_false_string tfs_ecat_fmmu_typewrite =
194 {
195 "Write in use", "Write ignore"
196 };
197
198 static const true_false_string tfs_ecat_fmmu_active =
199 {
200 "Enabled", "Disabled"
201 };
202
203 static const true_false_string tfs_ecat_syncman_flag0 =
204 {
205 "OPMODE xx", "OPMODE xx"
206 };
207
208 static const true_false_string tfs_ecat_syncman_flag1 =
209 {
210 "00: 3-Buf, 01: 3-Buf (Mon.), 10: 1-Buf", "00: 3-Buf, 01: 3-Buf (Mon.), 10: 1-Buf",
211 };
212
213 static const true_false_string tfs_ecat_syncman_flag2 =
214 {
215 "Write", "Read"
216 };
217
218 static const true_false_string tfs_ecat_syncman_flag4 =
219 {
220 "IRQ ECAT enabled", "IRQ ECAT disabled"
221 };
222
223 static const true_false_string tfs_ecat_syncman_flag5 =
224 {
225 "IRQ PDI enabled", "IRQ PDI disabled"
226 };
227
228 static const true_false_string tfs_ecat_syncman_flag8 =
229 {
230 "IRQ Write 1", "IRQ Write 0"
231 };
232
233 static const true_false_string tfs_ecat_syncman_flag9 =
234 {
235 "IRQ Read 1", "IRQ Read 0"
236 };
237
238 static const true_false_string tfs_ecat_syncman_flag10 =
239 {
240 "Watchdog", "No Watchdog"
241 };
242
243 static const true_false_string tfs_ecat_syncman_flag11 =
244 {
245 "1-Buf written", "1-Buf read"
246 };
247
248 static const true_false_string tfs_ecat_syncman_flag12 =
249 {
250 "Buffer Status xx", "Buffer Status xx"
251 };
252
253 static const true_false_string tfs_ecat_syncman_flag13 =
254 {
255 "00: 1.Buf, 01: 2.Buf, 10: 3.Buf", "00: 1.Buf, 01: 2.Buf, 10: 3.Buf"
256 };
257
258 static const true_false_string tfs_ecat_syncman_flag16 =
259 {
260 "SyncMan enabled", "SyncMan disabled",
261 };
262
263 static const char* convertEcCmdToText(int cmd, const value_string ec_cmd[])
264 {
265 return val_to_str(cmd, ec_cmd, "<UNKNOWN: %d>");
266 }
267
268 #define ENDOF(p) ((p)+1) /* pointer to end of *p*/
269
270 typedef enum
271 {
272 EC_CMD_TYPE_NOP = 0,
273 EC_CMD_TYPE_APRD = 1,
274 EC_CMD_TYPE_APWR = 2,
275 EC_CMD_TYPE_APRW = 3,
276 EC_CMD_TYPE_FPRD = 4,
277 EC_CMD_TYPE_FPWR = 5,
278 EC_CMD_TYPE_FPRW = 6,
279 EC_CMD_TYPE_BRD = 7,
280 EC_CMD_TYPE_BWR = 8,
281 EC_CMD_TYPE_BRW = 9,
282 EC_CMD_TYPE_LRD = 10,
283 EC_CMD_TYPE_LWR = 11,
284 EC_CMD_TYPE_LRW = 12,
285 EC_CMD_TYPE_ARMW = 13,
286 EC_CMD_TYPE_FRMW = 14,
287 EC_CMD_TYPE_EXT = 255
288 } EC_CMD_TYPE;
289
290 static void init_EcParserHDR(EcParserHDR* pHdr, tvbuff_t *tvb, gint offset)
291 {
292 pHdr->cmd = tvb_get_guint8(tvb, offset++);
293 pHdr->idx = tvb_get_guint8(tvb, offset++);
294 pHdr->anAddrUnion.a.adp = tvb_get_letohs(tvb, offset); offset+=(int)sizeof(guint16);
295 pHdr->anAddrUnion.a.ado = tvb_get_letohs(tvb, offset); offset+=(int)sizeof(guint16);
296 pHdr->len = tvb_get_letohs(tvb, offset); offset+=(int)sizeof(guint16);
297 pHdr->intr = tvb_get_letohs(tvb, offset);
298 }
299
300 static void init_dc_measure(guint32* pDC, tvbuff_t *tvb, gint offset)
301 {
302 int i;
303 for ( i=0; i<4; i++ )
304 {
305 pDC[i] = tvb_get_letohl(tvb, offset);
306 offset+=(int)sizeof(guint32);
307 }
308 }
309
310 static guint16 get_wc(EcParserHDR* pHdr, tvbuff_t *tvb, gint offset)
311 {
312 return tvb_get_letohs(tvb, offset+EcParserHDR_Len+(pHdr->len&0x07ff));
313 }
314
315 static guint16 get_cmd_len(EcParserHDR* pHdr)
316 {
317 return (EcParserHDR_Len+(pHdr->len&0x07ff)+sizeof(guint16)); /*Header + data + wc*/
318 }
319
320
321 static void EcSummaryFormater(guint32 datalength, tvbuff_t *tvb, gint offset, char *szText, gint nMax)
322 {
323 guint nSub=0;
324 guint nLen=0;
325 guint8 nCmds[4];
326 guint nLens[4];
327 EcParserHDR ecFirst;
328 EcParserHDR ecParser;
329
330 guint suboffset=0;
331
332 init_EcParserHDR(&ecFirst, tvb, offset);
333
334 while ( suboffset < datalength )
335 {
336 PEcParserHDR pEcParser;
337 if ( nSub > 0 )
338 {
339 init_EcParserHDR(&ecParser, tvb, offset+suboffset);
340 pEcParser = &ecParser;
341 }
342 else
343 pEcParser = &ecFirst;
344
345 if ( nSub < 4 )
346 {
347 nCmds[nSub] = pEcParser->cmd;
348 nLens[nSub] = pEcParser->len&0x07ff;
349 }
350 nSub++;
351 nLen += (pEcParser->len&0x07ff);
352 /* bit 14 -- roundtrip */
353
354 if ( (pEcParser->len&0x8000) == 0 )
355 break;
356
357 suboffset+=get_cmd_len(pEcParser);
358 }
359 if ( nSub == 1 )
360 {
361 guint16 len = ecFirst.len&0x07ff;
362 guint16 cnt = get_wc(&ecFirst, tvb, offset);
363 g_snprintf ( szText, nMax, "'%s': Len: %d, Adp 0x%x, Ado 0x%x, Wc %d ",
364 convertEcCmdToText(ecFirst.cmd, EcCmdShort), len, ecFirst.anAddrUnion.a.adp, ecFirst.anAddrUnion.a.ado, cnt );
365 }
366 else if ( nSub == 2 )
367 {
368 g_snprintf ( szText, nMax, "%d Cmds, '%s': len %d, '%s': len %d ",
369 nSub, convertEcCmdToText(nCmds[0], EcCmdShort), nLens[0], convertEcCmdToText(nCmds[1], EcCmdShort), nLens[1]);
370 }
371 else if ( nSub == 3 )
372 {
373 g_snprintf ( szText, nMax, "%d Cmds, '%s': len %d, '%s': len %d, '%s': len %d",
374 nSub, convertEcCmdToText(nCmds[0], EcCmdShort), nLens[0], convertEcCmdToText(nCmds[1], EcCmdShort), nLens[1], convertEcCmdToText(nCmds[2], EcCmdShort), nLens[2]);
375 }
376 else if ( nSub == 4 )
377 {
378 g_snprintf ( szText, nMax, "%d Cmds, '%s': len %d, '%s': len %d, '%s': len %d, '%s': len %d",
379 nSub, convertEcCmdToText(nCmds[0], EcCmdShort), nLens[0], convertEcCmdToText(nCmds[1], EcCmdShort), nLens[1], convertEcCmdToText(nCmds[2], EcCmdShort), nLens[2], convertEcCmdToText(nCmds[3], EcCmdShort), nLens[3]);
380 }
381 else
382 g_snprintf ( szText, nMax, "%d Cmds, SumLen %d, '%s'... ",
383 nSub, nLen, convertEcCmdToText(ecFirst.cmd, EcCmdShort));
384 }
385
386 static void EcCmdFormatter(guint8 cmd, char *szText, gint nMax)
387 {
388 gint idx=0;
389 const gchar *szCmd = try_val_to_str_idx((guint32)cmd, EcCmdLong, &idx);
390
391 if ( idx != -1 )
392 g_snprintf(szText, nMax, "Cmd : %d (%s)", cmd, szCmd);
393 else
394 g_snprintf(szText, nMax, "Cmd : %d (Unknown command)", cmd);
395 }
396
397
398 static void EcSubFormatter(tvbuff_t *tvb, gint offset, char *szText, gint nMax)
399 {
400 EcParserHDR ecParser;
401 guint16 len, cnt;
402
403 init_EcParserHDR(&ecParser, tvb, offset);
404 len = ecParser.len&0x07ff;
405 cnt = get_wc(&ecParser, tvb, offset);
406
407 switch ( ecParser.cmd )
408 {
409 case EC_CMD_TYPE_NOP:
410 case EC_CMD_TYPE_APRD:
411 case EC_CMD_TYPE_APWR:
412 case EC_CMD_TYPE_APRW:
413 case EC_CMD_TYPE_FPRD:
414 case EC_CMD_TYPE_FPWR:
415 case EC_CMD_TYPE_FPRW:
416 case EC_CMD_TYPE_BRD:
417 case EC_CMD_TYPE_BWR:
418 case EC_CMD_TYPE_BRW:
419 case EC_CMD_TYPE_ARMW:
420 case EC_CMD_TYPE_FRMW:
421 g_snprintf ( szText, nMax, "EtherCAT datagram: Cmd: '%s' (%d), Len: %d, Adp 0x%x, Ado 0x%x, Cnt %d",
422 convertEcCmdToText(ecParser.cmd, EcCmdShort), ecParser.cmd, len, ecParser.anAddrUnion.a.adp, ecParser.anAddrUnion.a.ado, cnt);
423 break;
424 case EC_CMD_TYPE_LRD:
425 case EC_CMD_TYPE_LWR:
426 case EC_CMD_TYPE_LRW:
427 g_snprintf ( szText, nMax, "EtherCAT datagram: Cmd: '%s' (%d), Len: %d, Addr 0x%x, Cnt %d",
428 convertEcCmdToText(ecParser.cmd, EcCmdShort), ecParser.cmd, len, ecParser.anAddrUnion.addr, cnt);
429 break;
430 case EC_CMD_TYPE_EXT:
431 g_snprintf ( szText, nMax, "EtherCAT datagram: Cmd: 'EXT' (%d), Len: %d", ecParser.cmd, len);
432 break;
433 default:
434 g_snprintf ( szText, nMax, "EtherCAT datagram: Cmd: 'Unknown' (%d), Len: %d", ecParser.cmd, len);
435 }
436 }
437
438 /* Ethercat Datagram */
439 static void dissect_ecat_datagram(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
440 {
441 tvbuff_t *next_tvb;
442 proto_item *ti, *aitem = NULL;
443 proto_tree *ecat_datagrams_tree = NULL;
444 guint offset = 0;
445 char szText[200];
446 int nMax = sizeof(szText)-1;
447 guint b;
448
449 guint ecLength=0;
450 guint subCount = 0;
451 const guint datagram_length = tvb_length_remaining(tvb, offset);
452 guint datagram_padding_bytes = 0;
453 EcParserHDR ecHdr;
454
455 col_set_str(pinfo->cinfo, COL_PROTOCOL, "ECAT");
456
457 col_clear(pinfo->cinfo, COL_INFO);
458
459 /* If the data portion of an EtherCAT datagram is less than 44 bytes, then
460 it must have been padded with an additional n number of bytes to reach a
461 total Ethernet frame length of 64 bytes (Ethernet header + Ethernet Data +
462 FCS). Hence at least 44 bytes data shall always be available in any
463 EtherCAT datagram. */
464 /* tvb_ensure_bytes_exist(tvb, offset, 44);
465 this is not correct, because the frame might have been captured before the
466 os added the padding bytes. E.g. in Windows the frames are captured on the
467 protocol layer. When another protocol driver sends a frame this frame does
468 not include the padding bytes.
469 */
470
471 /* Count the length of the individual EtherCAT datagrams (sub datagrams)
472 that are part of this EtherCAT frame. Stop counting when the current
473 sub datagram header tells that there are no more sub datagrams or when
474 there is no more data available in the PDU. */
475 do
476 {
477 init_EcParserHDR(&ecHdr, tvb, ecLength);
478 ecLength += get_cmd_len(&ecHdr);
479 } while ((ecLength < datagram_length) &&
480 (ecHdr.len & 0x8000));
481
482 /* Calculate the amount of padding data available in the PDU */
483 datagram_padding_bytes = datagram_length - ecLength;
484
485 EcSummaryFormater(ecLength, tvb, offset, szText, nMax);
486 col_append_str(pinfo->cinfo, COL_INFO, szText);
487
488 if( tree )
489 {
490 /* Create the EtherCAT datagram(s) subtree */
491 ti = proto_tree_add_item(tree, proto_ecat_datagram, tvb, 0, -1, ENC_NA);
492 ecat_datagrams_tree = proto_item_add_subtree(ti, ett_ecat);
493
494 proto_item_append_text(ti,": %s", szText);
495 }
496
497 /* Dissect all sub frames of this EtherCAT PDU */
498 do
499 {
500 proto_tree *ecat_datagram_tree = NULL, *ecat_header_tree = NULL, *ecat_fmmu_tree = NULL,
501 *ecat_fmmu_active_tree = NULL, *ecat_fmmu_type_tree = NULL, *ecat_syncman_tree = NULL,
502 *ecat_syncflag_tree = NULL, *ecat_dc_tree = NULL;
503 proto_item *hidden_item;
504
505 gint bMBox = FALSE;
506 guint32 subsize;
507 guint32 suboffset;
508 guint32 len;
509 ETHERCAT_MBOX_HEADER mbox;
510
511 suboffset = offset;
512 init_EcParserHDR(&ecHdr, tvb, suboffset);
513
514 subsize = get_cmd_len(&ecHdr);
515 len = ecHdr.len & 0x07ff;
516
517 if ( len >= sizeof(ETHERCAT_MBOX_HEADER_LEN) &&
518 (ecHdr.cmd==EC_CMD_TYPE_FPWR || ecHdr.cmd==EC_CMD_TYPE_FPRD || ecHdr.cmd==EC_CMD_TYPE_APWR || ecHdr.cmd==EC_CMD_TYPE_APRD) &&
519 ecHdr.anAddrUnion.a.ado>=0x1000
520 )
521 {
522 init_mbx_header(&mbox, tvb, suboffset+EcParserHDR_Len);
523
524 switch ( mbox.aControlUnion.v.Type )
525 {
526 case ETHERCAT_MBOX_TYPE_EOE:
527 case ETHERCAT_MBOX_TYPE_ADS:
528 case ETHERCAT_MBOX_TYPE_FOE:
529 case ETHERCAT_MBOX_TYPE_COE:
530 case ETHERCAT_MBOX_TYPE_SOE:
531 if ( /*pMBox->Length > 0 &&*/ mbox.Length <= 1500 /*&& pMBox->Length+sizeof(ETHERCAT_MBOX_HEADER_LEN) >= len*/ )
532 {
533 bMBox = TRUE;
534 }
535 break;
536 }
537 }
538
539 if( tree )
540 {
541 /* Create the sub tree for the current datagram */
542 EcSubFormatter(tvb, suboffset, szText, nMax);
543 aitem = proto_tree_add_text(ecat_datagrams_tree, tvb, suboffset, subsize, "%s", szText);
544 ecat_datagram_tree = proto_item_add_subtree(aitem, ett_ecat_datagram_subtree);
545
546 /* Create a subtree placeholder for the Header */
547 aitem = proto_tree_add_text(ecat_datagram_tree, tvb, offset, EcParserHDR_Len, "Header");
548 ecat_header_tree = proto_item_add_subtree(aitem, ett_ecat_header);
549
550 EcCmdFormatter(ecHdr.cmd, szText, nMax);
551 aitem = proto_tree_add_item(ecat_header_tree, hf_ecat_cmd, tvb, suboffset, sizeof(ecHdr.cmd), ENC_LITTLE_ENDIAN);
552 proto_item_set_text(aitem, "%s", szText);
553 if( subCount < 10 ){
554 aitem = proto_tree_add_item(ecat_header_tree, hf_ecat_sub_cmd[subCount], tvb, suboffset, sizeof(ecHdr.cmd), ENC_LITTLE_ENDIAN);
555 PROTO_ITEM_SET_HIDDEN(aitem);
556 }
557
558 suboffset+= (int)sizeof(ecHdr.cmd);
559
560 proto_tree_add_item(ecat_header_tree, hf_ecat_idx, tvb, suboffset, sizeof(ecHdr.idx), ENC_LITTLE_ENDIAN);
561 if( subCount < 10 ){
562 aitem = proto_tree_add_item(ecat_header_tree, hf_ecat_sub_idx[subCount], tvb, suboffset, sizeof(ecHdr.idx), ENC_LITTLE_ENDIAN);
563 PROTO_ITEM_SET_HIDDEN(aitem);
564 }
565 suboffset+= (int)sizeof(ecHdr.idx);
566
567 switch ( ecHdr.cmd )
568 {
569 case 10:
570 case 11:
571 case 12:
572 proto_tree_add_item(ecat_header_tree, hf_ecat_lad, tvb, suboffset, sizeof(ecHdr.anAddrUnion.a.adp)+sizeof(ecHdr.anAddrUnion.a.ado), ENC_LITTLE_ENDIAN);
573 if( subCount < 10 ){
574 aitem = proto_tree_add_item(ecat_header_tree, hf_ecat_sub_lad[subCount], tvb, suboffset, sizeof(ecHdr.anAddrUnion.a.adp)+sizeof(ecHdr.anAddrUnion.a.ado), ENC_LITTLE_ENDIAN);
575 PROTO_ITEM_SET_HIDDEN(aitem);
576 }
577
578 suboffset += (int)((sizeof(ecHdr.anAddrUnion.a.adp)+sizeof(ecHdr.anAddrUnion.a.ado)));
579 break;
580 default:
581 proto_tree_add_item(ecat_header_tree, hf_ecat_adp, tvb, suboffset, sizeof(ecHdr.anAddrUnion.a.adp), ENC_LITTLE_ENDIAN);
582 if( subCount < 10 ){
583 aitem = proto_tree_add_item(ecat_header_tree, hf_ecat_sub_adp[subCount], tvb, suboffset, sizeof(ecHdr.anAddrUnion.a.adp), ENC_LITTLE_ENDIAN);
584 PROTO_ITEM_SET_HIDDEN(aitem);
585 }
586
587 suboffset+= (int)sizeof(ecHdr.anAddrUnion.a.adp);
588 proto_tree_add_item(ecat_header_tree, hf_ecat_ado, tvb, suboffset, sizeof(ecHdr.anAddrUnion.a.ado), ENC_LITTLE_ENDIAN);
589 if( subCount < 10 ){
590 aitem = proto_tree_add_item(ecat_header_tree, hf_ecat_sub_ado[subCount], tvb, suboffset, sizeof(ecHdr.anAddrUnion.a.ado), ENC_LITTLE_ENDIAN);
591 PROTO_ITEM_SET_HIDDEN(aitem);
592 }
593
594 suboffset+= (int)sizeof(ecHdr.anAddrUnion.a.ado);
595 }
596
597 {
598 proto_tree *length_sub_tree;
599
600 /* Add information about the length field (11 bit length, 3 bits
601 reserved, 1 bit circulating frame and 1 bit more in a sub tree */
602 aitem = proto_tree_add_text(ecat_header_tree, tvb, suboffset, sizeof(ecHdr.len),
603 "Length : %d (0x%x) - %s - %s",
604 len, len, ecHdr.len & 0x4000 ? "Roundtrip" : "No Roundtrip", ecHdr.len & 0x8000 ? "More Follows..." : "Last Sub Command");
605 length_sub_tree = proto_item_add_subtree(aitem, ett_ecat_length);
606
607 proto_tree_add_item(length_sub_tree, hf_ecat_length_len, tvb, suboffset, sizeof(ecHdr.len), ENC_LITTLE_ENDIAN);
608 proto_tree_add_item(length_sub_tree, hf_ecat_length_r, tvb, suboffset, sizeof(ecHdr.len), ENC_LITTLE_ENDIAN);
609 proto_tree_add_item(length_sub_tree, hf_ecat_length_c, tvb, suboffset, sizeof(ecHdr.len), ENC_LITTLE_ENDIAN);
610 proto_tree_add_item(length_sub_tree, hf_ecat_length_m, tvb, suboffset, sizeof(ecHdr.len), ENC_LITTLE_ENDIAN);
611
612 suboffset+= (int)sizeof(ecHdr.len);
613 }
614
615 proto_tree_add_item(ecat_header_tree, hf_ecat_int, tvb, suboffset, sizeof(ecHdr.intr), ENC_LITTLE_ENDIAN);
616 suboffset+= (int)sizeof(ecHdr.intr);
617 }
618 else
619 {
620 suboffset+=EcParserHDR_Len;
621 }
622
623 if ( ecHdr.cmd>=1 && ecHdr.cmd<=9 && ecHdr.anAddrUnion.a.ado>=0x600 && ecHdr.anAddrUnion.a.ado<0x700 && (ecHdr.anAddrUnion.a.ado%16)==0 && (len%16)==0 )
624 {
625 if( tree )
626 {
627 /* Fieldbus Memory Management Units (FMMU) */
628 for ( b=0; b < MIN(16, len/16); b++ )
629 {
630 aitem = proto_tree_add_item(ecat_datagram_tree, hf_ecat_fmmu, tvb, suboffset, 16, ENC_NA);
631 proto_item_set_text(aitem, "Fieldbus Memory Management Units (FMMU)");
632
633 ecat_fmmu_tree = proto_item_add_subtree(aitem, ett_ecat_fmmu);
634
635 proto_tree_add_item(ecat_fmmu_tree, hf_ecat_fmmu_lstart, tvb, suboffset, 4, ENC_LITTLE_ENDIAN);
636 suboffset += 4;
637 proto_tree_add_item(ecat_fmmu_tree, hf_ecat_fmmu_llen, tvb, suboffset, 2, ENC_LITTLE_ENDIAN);
638 suboffset += 2;
639 proto_tree_add_item(ecat_fmmu_tree, hf_ecat_fmmu_lstartbit, tvb, suboffset, 1, ENC_LITTLE_ENDIAN);
640 suboffset += 1;
641 proto_tree_add_item(ecat_fmmu_tree, hf_ecat_fmmu_lendbit, tvb, suboffset, 1, ENC_LITTLE_ENDIAN);
642 suboffset += 1;
643 proto_tree_add_item(ecat_fmmu_tree, hf_ecat_fmmu_pstart, tvb, suboffset, 2, ENC_LITTLE_ENDIAN);
644 suboffset += 2;
645 proto_tree_add_item(ecat_fmmu_tree, hf_ecat_fmmu_pstartbit, tvb, suboffset, 1, ENC_LITTLE_ENDIAN);
646 suboffset += 1;
647 aitem = proto_tree_add_item(ecat_fmmu_tree, hf_ecat_fmmu_type, tvb, suboffset, 1, ENC_LITTLE_ENDIAN);
648 ecat_fmmu_type_tree = proto_item_add_subtree(aitem, ett_ecat_fmmu_type);
649 proto_tree_add_item(ecat_fmmu_type_tree, hf_ecat_fmmu_typeread, tvb, suboffset, 1, ENC_LITTLE_ENDIAN);
650 proto_tree_add_item(ecat_fmmu_type_tree, hf_ecat_fmmu_typewrite, tvb, suboffset, 1, ENC_LITTLE_ENDIAN);
651
652 suboffset += 1;
653 aitem = proto_tree_add_item(ecat_fmmu_tree, hf_ecat_fmmu_active, tvb, suboffset, 1, ENC_LITTLE_ENDIAN);
654 ecat_fmmu_active_tree = proto_item_add_subtree(aitem, ett_ecat_fmmu_active);
655 proto_tree_add_item(ecat_fmmu_active_tree, hf_ecat_fmmu_active0, tvb, suboffset, 1, ENC_LITTLE_ENDIAN);
656
657 suboffset += 4;
658 }
659 if ( len > 0x100 )
660 {
661 len -= 0x100;
662 for (b = 0; b < MIN(32, len / 8); b++)
663 {
664 aitem = proto_tree_add_item(ecat_datagram_tree, hf_ecat_syncman, tvb, suboffset, 8, ENC_NA);
665 proto_item_set_text(aitem, "SyncManager");
666 ecat_syncman_tree = proto_item_add_subtree(aitem, ett_ecat_syncman);
667
668 proto_tree_add_item(ecat_syncman_tree, hf_ecat_syncman_start, tvb, suboffset, 2, ENC_LITTLE_ENDIAN);
669 suboffset+=2;
670 proto_tree_add_item(ecat_syncman_tree, hf_ecat_syncman_len, tvb, suboffset, 2, ENC_LITTLE_ENDIAN);
671 suboffset+=2;
672
673 aitem = proto_tree_add_item(ecat_syncman_tree, hf_ecat_syncman_flags, tvb, suboffset, 4, ENC_LITTLE_ENDIAN);
674 ecat_syncflag_tree = proto_item_add_subtree(aitem, ett_ecat_syncflag);
675 proto_tree_add_item(ecat_syncflag_tree, hf_ecat_syncman_flag0, tvb, suboffset, 4, ENC_LITTLE_ENDIAN);
676 proto_tree_add_item(ecat_syncflag_tree, hf_ecat_syncman_flag1, tvb, suboffset, 4, ENC_LITTLE_ENDIAN);
677 proto_tree_add_item(ecat_syncflag_tree, hf_ecat_syncman_flag2, tvb, suboffset, 4, ENC_LITTLE_ENDIAN);
678 proto_tree_add_item(ecat_syncflag_tree, hf_ecat_syncman_flag4, tvb, suboffset, 4, ENC_LITTLE_ENDIAN);
679 proto_tree_add_item(ecat_syncflag_tree, hf_ecat_syncman_flag5, tvb, suboffset, 4, ENC_LITTLE_ENDIAN);
680 proto_tree_add_item(ecat_syncflag_tree, hf_ecat_syncman_flag8, tvb, suboffset, 4, ENC_LITTLE_ENDIAN);
681 proto_tree_add_item(ecat_syncflag_tree, hf_ecat_syncman_flag9, tvb, suboffset, 4, ENC_LITTLE_ENDIAN);
682 proto_tree_add_item(ecat_syncflag_tree, hf_ecat_syncman_flag10, tvb, suboffset, 4, ENC_LITTLE_ENDIAN);
683 proto_tree_add_item(ecat_syncflag_tree, hf_ecat_syncman_flag11, tvb, suboffset, 4, ENC_LITTLE_ENDIAN);
684 proto_tree_add_item(ecat_syncflag_tree, hf_ecat_syncman_flag12, tvb, suboffset, 4, ENC_LITTLE_ENDIAN);
685 proto_tree_add_item(ecat_syncflag_tree, hf_ecat_syncman_flag13, tvb, suboffset, 4, ENC_LITTLE_ENDIAN);
686 proto_tree_add_item(ecat_syncflag_tree, hf_ecat_syncman_flag16, tvb, suboffset, 4, ENC_LITTLE_ENDIAN);
687 suboffset+=4;
688 }
689 }
690 }
691 }
692 else if ( ecHdr.cmd>=1 && ecHdr.cmd<=9 && ecHdr.anAddrUnion.a.ado>=0x800 && ecHdr.anAddrUnion.a.ado<0x880 && (ecHdr.anAddrUnion.a.ado%8)==0 && (len%8)==0 )
693 {
694 if( tree )
695 {
696 /* SyncManager */
697 for (b = 0; b < MIN(32, len / 8); b++)
698 {
699 aitem = proto_tree_add_item(ecat_datagram_tree, hf_ecat_syncman, tvb, suboffset, 8, ENC_NA);
700 proto_item_set_text(aitem, "SyncManager");
701 ecat_syncman_tree = proto_item_add_subtree(aitem, ett_ecat_syncman);
702
703 proto_tree_add_item(ecat_syncman_tree, hf_ecat_syncman_start, tvb, suboffset, 2, ENC_LITTLE_ENDIAN);
704 suboffset+=2;
705 proto_tree_add_item(ecat_syncman_tree, hf_ecat_syncman_len, tvb, suboffset, 2, ENC_LITTLE_ENDIAN);
706 suboffset+=2;
707
708 aitem = proto_tree_add_item(ecat_syncman_tree, hf_ecat_syncman_flags, tvb, suboffset, 4, ENC_LITTLE_ENDIAN);
709 ecat_syncflag_tree = proto_item_add_subtree(aitem, ett_ecat_syncflag);
710 proto_tree_add_item(ecat_syncflag_tree, hf_ecat_syncman_flag0, tvb, suboffset, 4, ENC_LITTLE_ENDIAN);
711 proto_tree_add_item(ecat_syncflag_tree, hf_ecat_syncman_flag1, tvb, suboffset, 4, ENC_LITTLE_ENDIAN);
712 proto_tree_add_item(ecat_syncflag_tree, hf_ecat_syncman_flag2, tvb, suboffset, 4, ENC_LITTLE_ENDIAN);
713 proto_tree_add_item(ecat_syncflag_tree, hf_ecat_syncman_flag4, tvb, suboffset, 4, ENC_LITTLE_ENDIAN);
714 proto_tree_add_item(ecat_syncflag_tree, hf_ecat_syncman_flag5, tvb, suboffset, 4, ENC_LITTLE_ENDIAN);
715 proto_tree_add_item(ecat_syncflag_tree, hf_ecat_syncman_flag8, tvb, suboffset, 4, ENC_LITTLE_ENDIAN);
716 proto_tree_add_item(ecat_syncflag_tree, hf_ecat_syncman_flag9, tvb, suboffset, 4, ENC_LITTLE_ENDIAN);
717 proto_tree_add_item(ecat_syncflag_tree, hf_ecat_syncman_flag10, tvb, suboffset, 4, ENC_LITTLE_ENDIAN);
718 proto_tree_add_item(ecat_syncflag_tree, hf_ecat_syncman_flag11, tvb, suboffset, 4, ENC_LITTLE_ENDIAN);
719 proto_tree_add_item(ecat_syncflag_tree, hf_ecat_syncman_flag12, tvb, suboffset, 4, ENC_LITTLE_ENDIAN);
720 proto_tree_add_item(ecat_syncflag_tree, hf_ecat_syncman_flag13, tvb, suboffset, 4, ENC_LITTLE_ENDIAN);
721 proto_tree_add_item(ecat_syncflag_tree, hf_ecat_syncman_flag16, tvb, suboffset, 4, ENC_LITTLE_ENDIAN);
722 suboffset+=4;
723 }
724 }
725 }
726 else if ( (ecHdr.cmd == 1 || ecHdr.cmd == 4) && ecHdr.anAddrUnion.a.ado == 0x900 && ecHdr.len >= 16 )
727 {
728 if (tree)
729 {
730 guint32 pDC[4];
731 init_dc_measure(pDC, tvb, suboffset);
732
733 /* Allow sub dissectors to have a chance with this data */
734 if(!dissector_try_heuristic(heur_subdissector_list, tvb, pinfo, ecat_datagram_tree, NULL))
735 {
736 /* No sub dissector did recognize this data, dissect it as data only */
737 aitem = proto_tree_add_item(ecat_datagram_tree, hf_ecat_data, tvb, suboffset, ecHdr.len & 0x07ff, ENC_NA);
738 ecat_dc_tree = proto_item_add_subtree(aitem, ett_ecat_dc);
739 }
740 else
741 {
742 /* A sub dissector handled the data, allow the rest of the
743 to add data to the correct place in the tree hierarchy. */
744 ecat_dc_tree = ecat_datagram_tree;
745 }
746
747 if( subCount < 10 ){
748 aitem = proto_tree_add_item(ecat_datagram_tree, hf_ecat_sub_data[subCount], tvb, offset + EcParserHDR_Len, ecHdr.len & 0x07ff, ENC_NA);
749 PROTO_ITEM_SET_HIDDEN(aitem);
750 }
751
752 if ( pDC[3] != 0 )
753 {
754 proto_tree_add_uint(ecat_dc_tree, hf_ecat_dc_diff_da, tvb, suboffset, 4, pDC[3] - pDC[0]);
755 if( subCount < 10 ){
756 hidden_item = proto_tree_add_uint(ecat_dc_tree, hf_ecat_sub_dc_diff_da[subCount], tvb, suboffset, 4, pDC[3] - pDC[0]);
757 PROTO_ITEM_SET_HIDDEN(hidden_item);
758 }
759
760 if ( pDC[1] != 0 )
761 {
762 proto_tree_add_uint(ecat_dc_tree, hf_ecat_dc_diff_bd, tvb, suboffset, 4, pDC[1] - pDC[3]);
763 if( subCount < 10 ){
764 hidden_item = proto_tree_add_uint(ecat_dc_tree, hf_ecat_sub_dc_diff_bd[subCount], tvb, suboffset, 4, pDC[1] - pDC[3]);
765 PROTO_ITEM_SET_HIDDEN(hidden_item);
766 }
767 }
768 else if ( pDC[2] != 0 )
769 {
770 proto_tree_add_uint(ecat_dc_tree, hf_ecat_dc_diff_cd, tvb, suboffset, 4, pDC[2] - pDC[3]);
771 if( subCount < 10 ){
772 hidden_item = proto_tree_add_uint(ecat_dc_tree, hf_ecat_sub_dc_diff_cd[subCount], tvb, suboffset, 4, pDC[2] - pDC[3]);
773 PROTO_ITEM_SET_HIDDEN(hidden_item);
774 }
775 }
776 }
777 if ( pDC[1] != 0 )
778 {
779 proto_tree_add_uint(ecat_dc_tree, hf_ecat_dc_diff_ba, tvb, suboffset, 4, pDC[1] - pDC[0]);
780 if( subCount < 10 ){
781 hidden_item = proto_tree_add_uint(ecat_dc_tree, hf_ecat_sub_dc_diff_ba[subCount], tvb, suboffset, 4, pDC[1] - pDC[0]);
782 PROTO_ITEM_SET_HIDDEN(hidden_item);
783 }
784 if ( pDC[2] != 0 )
785 {
786 proto_tree_add_uint(ecat_dc_tree, hf_ecat_dc_diff_cb, tvb, suboffset, 4, pDC[2] - pDC[1]);
787 if( subCount < 10 ){
788 hidden_item = proto_tree_add_uint(ecat_dc_tree, hf_ecat_sub_dc_diff_cb[subCount], tvb, suboffset, 4, pDC[2] - pDC[1]);
789 PROTO_ITEM_SET_HIDDEN(hidden_item);
790 }
791 }
792 }
793 else if ( pDC[2] != 0 )
794 {
795 proto_tree_add_uint(ecat_dc_tree, hf_ecat_dc_diff_ca, tvb, suboffset, 4, pDC[2] - pDC[0]);
796 if( subCount < 10 ){
797 hidden_item = proto_tree_add_uint(ecat_dc_tree, hf_ecat_sub_dc_diff_ca[subCount], tvb, suboffset, 4, pDC[2] - pDC[0]);
798 PROTO_ITEM_SET_HIDDEN(hidden_item);
799 }
800 }
801 }
802 }
803 else if ( bMBox )
804 {
805 const guint MBoxLength = mbox.Length + 6 /* MBOX header length */;
806
807 next_tvb = tvb_new_subset(tvb, suboffset, MBoxLength, MBoxLength);
808 call_dissector(ecat_mailbox_handle, next_tvb, pinfo, ecat_datagram_tree);
809
810 if( tree )
811 {
812 const guint startOfData = offset + EcParserHDR_Len + MBoxLength;
813 const guint dataLength = (ecHdr.len & 0x7ff) - MBoxLength;
814 if ( dataLength > 0 )
815 {
816 /* Allow sub dissectors to have a chance with this data */
817 if(!dissector_try_heuristic(heur_subdissector_list, tvb, pinfo, ecat_datagram_tree, NULL))
818 {
819 /* No sub dissector did recognize this data, dissect it as data only */
820 proto_tree_add_item(ecat_datagram_tree, hf_ecat_data, tvb, startOfData, dataLength, ENC_NA);
821 }
822
823 if( subCount < 10 ){
824 aitem = proto_tree_add_item(ecat_datagram_tree, hf_ecat_sub_data[subCount], tvb, startOfData, dataLength, ENC_NA);
825 PROTO_ITEM_SET_HIDDEN(aitem);
826 }
827 }
828 }
829 }
830 else
831 {
832 if( tree )
833 {
834 /* Allow sub dissectors to have a chance with this data */
835 if(!dissector_try_heuristic(heur_subdissector_list, tvb, pinfo, ecat_datagram_tree, NULL))
836 {
837 /* No sub dissector did recognize this data, dissect it as data only */
838 proto_tree_add_item(ecat_datagram_tree, hf_ecat_data, tvb, suboffset, ecHdr.len & 0x07ff, ENC_NA);
839 }
840
841 if( subCount < 10 ){
842 aitem = proto_tree_add_item(ecat_datagram_tree, hf_ecat_sub_data[subCount], tvb, offset + EcParserHDR_Len, ecHdr.len & 0x07ff, ENC_NA);
843 PROTO_ITEM_SET_HIDDEN(aitem);
844 }
845 }
846 }
847
848 if( tree )
849 {
850 proto_tree_add_item(ecat_datagram_tree, hf_ecat_cnt, tvb, offset + EcParserHDR_Len + len , 2, ENC_LITTLE_ENDIAN);
851 if( subCount < 10 ){
852 aitem = proto_tree_add_item(ecat_datagram_tree, hf_ecat_sub_cnt[subCount], tvb, offset + EcParserHDR_Len + len , 2, ENC_LITTLE_ENDIAN);
853 PROTO_ITEM_SET_HIDDEN(aitem);
854 }
855 }
856
857 offset+=subsize;
858 subCount++;
859 } while((offset < datagram_length) &&
860 (ecHdr.len & 0x8000));
861
862 /* Add information that states which portion of the PDU that is pad bytes.
863 These are added just to get an Ethernet frame size of at least 64 bytes,
864 which is required by the protocol specification */
865 if(datagram_padding_bytes > 0)
866 {
867 proto_tree_add_item(tree, hf_ecat_padding, tvb, offset, tvb_length_remaining(tvb, offset), ENC_NA);
868 }
869 }
870
871 void proto_register_ecat(void)
872 {
873 static hf_register_info hf[] =
874 {
875 { &hf_ecat_sub,
876 { "EtherCAT Frame", "ecat.sub", FT_BYTES, BASE_NONE, NULL, 0x0,
877 NULL, HFILL }
878 },
879 #if 0
880 { &hf_ecat_header,
881 { "eader", "ecat.header",
882 FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }
883 },
884 #endif
885 { &hf_ecat_sub_data[0],
886 { "Data", "ecat.sub1.data",
887 FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }
888 },
889 { &hf_ecat_sub_data[1],
890 { "Data", "ecat.sub2.data",
891 FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }
892 },
893 { &hf_ecat_sub_data[2],
894 { "Data", "ecat.sub3.data",
895 FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }
896 },
897 { &hf_ecat_sub_data[3],
898 { "Data", "ecat.sub4.data",
899 FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }
900 },
901 { &hf_ecat_sub_data[4],
902 { "Data", "ecat.sub5.data",
903 FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }
904 },
905 { &hf_ecat_sub_data[5],
906 { "Data", "ecat.sub6.data",
907 FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }
908 },
909 { &hf_ecat_sub_data[6],
910 { "Data", "ecat.sub7.data",
911 FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }
912 },
913 { &hf_ecat_sub_data[7],
914 { "Data", "ecat.sub8.data",
915 FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }
916 },
917 { &hf_ecat_sub_data[8],
918 { "Data", "ecat.sub9.data",
919 FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }
920 },
921 { &hf_ecat_sub_data[9],
922 { "Data", "ecat.sub10.data",
923 FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }
924 },
925 { &hf_ecat_data,
926 { "Data", "ecat.data",
927 FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }
928 },
929 { &hf_ecat_cnt,
930 { "Working Cnt", "ecat.cnt",
931 FT_UINT16, BASE_DEC, NULL, 0x0, "The working counter is increased once for each addressed device if at least one byte/bit of the data was successfully read and/or written by that device, it is increased once for every operation made by that device - read/write/read and write", HFILL }
932 },
933 { &hf_ecat_sub_cnt[0],
934 { "Working Cnt", "ecat.sub1.cnt",
935 FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }
936 },
937 { &hf_ecat_sub_cnt[1],
938 { "Working Cnt", "ecat.sub2.cnt",
939 FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }
940 },
941 { &hf_ecat_sub_cnt[2],
942 { "Working Cnt", "ecat.sub3.cnt",
943 FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }
944 },
945 { &hf_ecat_sub_cnt[3],
946 { "Working Cnt", "ecat.sub4.cnt",
947 FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }
948 },
949 { &hf_ecat_sub_cnt[4],
950 { "Working Cnt", "ecat.sub5.cnt",
951 FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }
952 },
953 { &hf_ecat_sub_cnt[5],
954 { "Working Cnt", "ecat.sub6.cnt",
955 FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }
956 },
957 { &hf_ecat_sub_cnt[6],
958 { "Working Cnt", "ecat.sub7.cnt",
959 FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }
960 },
961 { &hf_ecat_sub_cnt[7],
962 { "Working Cnt", "ecat.sub8.cnt",
963 FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }
964 },
965 { &hf_ecat_sub_cnt[8],
966 { "Working Cnt", "ecat.sub9.cnt",
967 FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }
968 },
969 { &hf_ecat_sub_cnt[9],
970 { "Working Cnt", "ecat.sub10.cnt",
971 FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }
972 },
973 { &hf_ecat_cmd,
974 { "Command", "ecat.cmd",
975 FT_UINT8, BASE_HEX, VALS(EcCmdShort), 0x0, NULL, HFILL }
976 },
977 { &hf_ecat_sub_cmd[0],
978 { "Command", "ecat.sub1.cmd",
979 FT_UINT8, BASE_HEX, VALS(EcCmdShort), 0x0, NULL, HFILL }
980 },
981 { &hf_ecat_sub_cmd[1],
982 { "Command", "ecat.sub2.cmd",
983 FT_UINT8, BASE_HEX, VALS(EcCmdShort), 0x0, NULL, HFILL }
984 },
985 { &hf_ecat_sub_cmd[2],
986 { "Command", "ecat.sub3.cmd",
987 FT_UINT8, BASE_HEX, VALS(EcCmdShort), 0x0, NULL, HFILL }
988 },
989 { &hf_ecat_sub_cmd[3],
990 { "Command", "ecat.sub4.cmd",
991 FT_UINT8, BASE_HEX, VALS(EcCmdShort), 0x0, NULL, HFILL }
992 },
993 { &hf_ecat_sub_cmd[4],
994 { "Command", "ecat.sub5.cmd",
995 FT_UINT8, BASE_HEX, VALS(EcCmdShort), 0x0, NULL, HFILL }
996 },
997 { &hf_ecat_sub_cmd[5],
998 { "Command", "ecat.sub6.cmd",
999 FT_UINT8, BASE_HEX, VALS(EcCmdShort), 0x0, NULL, HFILL }
1000 },
1001 { &hf_ecat_sub_cmd[6],
1002 { "Command", "ecat.sub7.cmd",
1003 FT_UINT8, BASE_HEX, VALS(EcCmdShort), 0x0, NULL, HFILL }
1004 },
1005 { &hf_ecat_sub_cmd[7],
1006 { "Command", "ecat.sub8.cmd",
1007 FT_UINT8, BASE_HEX, VALS(EcCmdShort), 0x0, NULL, HFILL }
1008 },
1009 { &hf_ecat_sub_cmd[8],
1010 { "Command", "ecat.sub9.cmd",
1011 FT_UINT8, BASE_HEX, VALS(EcCmdShort), 0x0, NULL, HFILL }
1012 },
1013 { &hf_ecat_sub_cmd[9],
1014 { "Command", "ecat.sub10.cmd",
1015 FT_UINT8, BASE_HEX, VALS(EcCmdShort), 0x0, NULL, HFILL }
1016 },
1017 { &hf_ecat_idx,
1018 { "Index", "ecat.idx",
1019 FT_UINT8, BASE_HEX, NULL, 0x0,
1020 NULL, HFILL }
1021 },
1022 { &hf_ecat_sub_idx[0],
1023 { "Index", "ecat.sub1.idx",
1024 FT_UINT8, BASE_HEX, NULL, 0x0,
1025 NULL, HFILL }
1026 },
1027 { &hf_ecat_sub_idx[1],
1028 { "Index", "ecat.sub2.idx",
1029 FT_UINT8, BASE_HEX, NULL, 0x0,
1030 NULL, HFILL }
1031 },
1032 { &hf_ecat_sub_idx[2],
1033 { "Index", "ecat.sub3.idx",
1034 FT_UINT8, BASE_HEX, NULL, 0x0,
1035 NULL, HFILL }
1036 },
1037 { &hf_ecat_sub_idx[3],
1038 { "Index", "ecat.sub4.idx",
1039 FT_UINT8, BASE_HEX, NULL, 0x0,
1040 NULL, HFILL }
1041 },
1042 { &hf_ecat_sub_idx[4],
1043 { "Index", "ecat.sub5.idx",
1044 FT_UINT8, BASE_HEX, NULL, 0x0,
1045 NULL, HFILL }
1046 },
1047 { &hf_ecat_sub_idx[5],
1048 { "Index", "ecat.sub6.idx",
1049 FT_UINT8, BASE_HEX, NULL, 0x0,
1050 NULL, HFILL }
1051 },
1052 { &hf_ecat_sub_idx[6],
1053 { "Index", "ecat.sub7.idx",
1054 FT_UINT8, BASE_HEX, NULL, 0x0,
1055 NULL, HFILL }
1056 },
1057 { &hf_ecat_sub_idx[7],
1058 { "Index", "ecat.sub8.idx",
1059 FT_UINT8, BASE_HEX, NULL, 0x0,
1060 NULL, HFILL }
1061 },
1062 { &hf_ecat_sub_idx[8],
1063 { "Index", "ecat.sub9.idx",
1064 FT_UINT8, BASE_HEX, NULL, 0x0,
1065 NULL, HFILL }
1066 },
1067 { &hf_ecat_sub_idx[9],
1068 { "Index", "ecat.sub10.idx",
1069 FT_UINT8, BASE_HEX, NULL, 0x0,
1070 NULL, HFILL }
1071 },
1072 { &hf_ecat_adp,
1073 { "Slave Addr", "ecat.adp",
1074 FT_UINT16, BASE_HEX, NULL, 0x0,
1075 NULL, HFILL }
1076 },
1077 { &hf_ecat_sub_adp[0],
1078 { "Slave Addr", "ecat.sub1.adp",
1079 FT_UINT16, BASE_HEX, NULL, 0x0,
1080 NULL, HFILL }
1081 },
1082 { &hf_ecat_sub_adp[1],
1083 { "Slave Addr", "ecat.sub2.adp",
1084 FT_UINT16, BASE_HEX, NULL, 0x0,
1085 NULL, HFILL }
1086 },
1087 { &hf_ecat_sub_adp[2],
1088 { "Slave Addr", "ecat.sub3.adp",
1089 FT_UINT16, BASE_HEX, NULL, 0x0,
1090 NULL, HFILL }
1091 },
1092 { &hf_ecat_sub_adp[3],
1093 { "Slave Addr", "ecat.sub4.adp",
1094 FT_UINT16, BASE_HEX, NULL, 0x0,
1095 NULL, HFILL }
1096 },
1097 { &hf_ecat_sub_adp[4],
1098 { "Slave Addr", "ecat.sub5.adp",
1099 FT_UINT16, BASE_HEX, NULL, 0x0,
1100 NULL, HFILL }
1101 },
1102 { &hf_ecat_sub_adp[5],
1103 { "Slave Addr", "ecat.sub6.adp",
1104 FT_UINT16, BASE_HEX, NULL, 0x0,
1105 NULL, HFILL }
1106 },
1107 { &hf_ecat_sub_adp[6],
1108 { "Slave Addr", "ecat.sub7.adp",
1109 FT_UINT16, BASE_HEX, NULL, 0x0,
1110 NULL, HFILL }
1111 },
1112 { &hf_ecat_sub_adp[7],
1113 { "Slave Addr", "ecat.sub8.adp",
1114 FT_UINT16, BASE_HEX, NULL, 0x0,
1115 NULL, HFILL }
1116 },
1117 { &hf_ecat_sub_adp[8],
1118 { "Slave Addr", "ecat.sub9.adp",
1119 FT_UINT16, BASE_HEX, NULL, 0x0,
1120 NULL, HFILL }
1121 },
1122 { &hf_ecat_sub_adp[9],
1123 { "Slave Addr", "ecat.sub10.adp",
1124 FT_UINT16, BASE_HEX, NULL, 0x0,
1125 NULL, HFILL }
1126 },
1127 { &hf_ecat_ado,
1128 { "Offset Addr", "ecat.ado",
1129 FT_UINT16, BASE_HEX, NULL, 0x0,
1130 NULL, HFILL }
1131 },
1132 { &hf_ecat_sub_ado[0],
1133 { "Offset Addr", "ecat.sub1.ado",
1134 FT_UINT16, BASE_HEX, NULL, 0x0,
1135 NULL, HFILL }
1136 },
1137 { &hf_ecat_sub_ado[1],
1138 { "Offset Addr", "ecat.sub2.ado",
1139 FT_UINT16, BASE_HEX, NULL, 0x0,
1140 NULL, HFILL }
1141 },
1142 { &hf_ecat_sub_ado[2],
1143 { "Offset Addr", "ecat.sub3.ado",
1144 FT_UINT16, BASE_HEX, NULL, 0x0,
1145 NULL, HFILL }
1146 },
1147 { &hf_ecat_sub_ado[3],
1148 { "Offset Addr", "ecat.sub4.ado",
1149 FT_UINT16, BASE_HEX, NULL, 0x0,
1150 NULL, HFILL }
1151 },
1152 { &hf_ecat_sub_ado[4],
1153 { "Offset Addr", "ecat.sub5.ado",
1154 FT_UINT16, BASE_HEX, NULL, 0x0,
1155 NULL, HFILL }
1156 },
1157 { &hf_ecat_sub_ado[5],
1158 { "Offset Addr", "ecat.sub6.ado",
1159 FT_UINT16, BASE_HEX, NULL, 0x0,
1160 NULL, HFILL }
1161 },
1162 { &hf_ecat_sub_ado[6],
1163 { "Offset Addr", "ecat.sub7.ado",
1164 FT_UINT16, BASE_HEX, NULL, 0x0,
1165 NULL, HFILL }
1166 },
1167 { &hf_ecat_sub_ado[7],
1168 { "Offset Addr", "ecat.sub8.ado",
1169 FT_UINT16, BASE_HEX, NULL, 0x0,
1170 NULL, HFILL }
1171 },
1172 { &hf_ecat_sub_ado[8],
1173 { "Offset Addr", "ecat.sub9.ado",
1174 FT_UINT16, BASE_HEX, NULL, 0x0,
1175 NULL, HFILL }
1176 },
1177 { &hf_ecat_sub_ado[9],
1178 { "Offset Addr", "ecat.sub10.ado",
1179 FT_UINT16, BASE_HEX, NULL, 0x0,
1180 NULL, HFILL }
1181 },
1182 { &hf_ecat_lad,
1183 { "Log Addr", "ecat.lad",
1184 FT_UINT32, BASE_HEX, NULL, 0x0,
1185 NULL, HFILL }
1186 },
1187 { &hf_ecat_sub_lad[0],
1188 { "Log Addr", "ecat.sub1.lad",
1189 FT_UINT32, BASE_HEX, NULL, 0x0,
1190 NULL, HFILL }
1191 },
1192 { &hf_ecat_sub_lad[1],
1193 { "Log Addr", "ecat.sub2.lad",
1194 FT_UINT32, BASE_HEX, NULL, 0x0,
1195 NULL, HFILL }
1196 },
1197 { &hf_ecat_sub_lad[2],
1198 { "Log Addr", "ecat.sub3.lad",
1199 FT_UINT32, BASE_HEX, NULL, 0x0,
1200 NULL, HFILL }
1201 },
1202 { &hf_ecat_sub_lad[3],
1203 { "Log Addr", "ecat.sub4.lad",
1204 FT_UINT32, BASE_HEX, NULL, 0x0,
1205 NULL, HFILL }
1206 },
1207 { &hf_ecat_sub_lad[4],
1208 { "Log Addr", "ecat.sub5.lad",
1209 FT_UINT32, BASE_HEX, NULL, 0x0,
1210 NULL, HFILL }
1211 },
1212 { &hf_ecat_sub_lad[5],
1213 { "Log Addr", "ecat.sub6.lad",
1214 FT_UINT32, BASE_HEX, NULL, 0x0,
1215 NULL, HFILL }
1216 },
1217 { &hf_ecat_sub_lad[6],
1218 { "Log Addr", "ecat.sub7.lad",
1219 FT_UINT32, BASE_HEX, NULL, 0x0,
1220 NULL, HFILL }
1221 },
1222 { &hf_ecat_sub_lad[7],
1223 { "Log Addr", "ecat.sub8.lad",
1224 FT_UINT32, BASE_HEX, NULL, 0x0,
1225 NULL, HFILL }
1226 },
1227 { &hf_ecat_sub_lad[8],
1228 { "Log Addr", "ecat.sub9.lad",
1229 FT_UINT32, BASE_HEX, NULL, 0x0,
1230 NULL, HFILL }
1231 },
1232 { &hf_ecat_sub_lad[9],
1233 { "Log Addr", "ecat.sub10.lad",
1234 FT_UINT32, BASE_HEX, NULL, 0x0,
1235 NULL, HFILL }
1236 },
1237 #if 0
1238 { &hf_ecat_len,
1239 { "Length", "ecat.len",
1240 FT_UINT16, BASE_DEC, NULL, 0x0,
1241 NULL, HFILL }
1242 },
1243 #endif
1244 { &hf_ecat_int,
1245 { "Interrupt", "ecat.int",
1246 FT_UINT16, BASE_HEX, NULL, 0x0,
1247 NULL, HFILL }
1248 },
1249 { &hf_ecat_syncman,
1250 { "SyncManager", "ecat.syncman",
1251 FT_BYTES, BASE_NONE, NULL, 0x0,
1252 NULL, HFILL }
1253 },
1254 { &hf_ecat_syncman_start,
1255 { "Start Addr", "ecat.syncman.start",
1256 FT_UINT16, BASE_HEX, NULL, 0x0,
1257 NULL, HFILL }
1258 },
1259 { &hf_ecat_syncman_len,
1260 { "SM Length", "ecat.syncman.len",
1261 FT_UINT16, BASE_HEX, NULL, 0x0,
1262 NULL, HFILL }
1263 },
1264 { &hf_ecat_syncman_flags,
1265 { "SM Flags", "ecat.syncman.flags",
1266 FT_UINT32, BASE_HEX, NULL, 0x0,
1267 NULL, HFILL }
1268 },
1269 { &hf_ecat_syncman_flag0,
1270 { "SM Flag0", "ecat.syncman_flag0",
1271 FT_BOOLEAN, 32, TFS(&tfs_ecat_syncman_flag0), 0x00000001,
1272 NULL, HFILL }
1273 },
1274 { &hf_ecat_syncman_flag1,
1275 { "SM Flag1", "ecat.syncman_flag1",
1276 FT_BOOLEAN, 32, TFS(&tfs_ecat_syncman_flag1), 0x00000002,
1277 NULL, HFILL }
1278 },
1279 { &hf_ecat_syncman_flag2,
1280 { "SM Flag2", "ecat.syncman_flag2",
1281 FT_BOOLEAN, 32, TFS(&tfs_ecat_syncman_flag2), 0x00000004,
1282 NULL, HFILL }
1283 },
1284 { &hf_ecat_syncman_flag4,
1285 { "SM Flag4", "ecat.syncman_flag4",
1286 FT_BOOLEAN, 32, TFS(&tfs_ecat_syncman_flag4), 0x00000010,
1287 NULL, HFILL }
1288 },
1289 { &hf_ecat_syncman_flag5,
1290 { "SM Flag5", "ecat.syncman_flag5",
1291 FT_BOOLEAN, 32, TFS(&tfs_ecat_syncman_flag5), 0x00000020,
1292 NULL, HFILL }
1293 },
1294 { &hf_ecat_syncman_flag8,
1295 { "SM Flag8", "ecat.syncman_flag8",
1296 FT_BOOLEAN, 32, TFS(&tfs_ecat_syncman_flag8), 0x00000100,
1297 NULL, HFILL }
1298 },
1299 { &hf_ecat_syncman_flag9,
1300 { "SM Flag9", "ecat.syncman_flag9",
1301 FT_BOOLEAN, 32, TFS(&tfs_ecat_syncman_flag9), 0x00000200,
1302 NULL, HFILL }
1303 },
1304 { &hf_ecat_syncman_flag10,
1305 { "SM Flag10", "ecat.syncman_flag10",
1306 FT_BOOLEAN, 32, TFS(&tfs_ecat_syncman_flag10), 0x00000400,
1307 NULL, HFILL }
1308 },
1309 { &hf_ecat_syncman_flag11,
1310 { "SM Flag11", "ecat.syncman_flag11",
1311 FT_BOOLEAN, 32, TFS(&tfs_ecat_syncman_flag11), 0x00000800,
1312 NULL, HFILL }
1313 },
1314 { &hf_ecat_syncman_flag12,
1315 { "SM Flag12", "ecat.syncman_flag12",
1316 FT_BOOLEAN, 32, TFS(&tfs_ecat_syncman_flag12), 0x00001000,
1317 NULL, HFILL }
1318 },
1319 { &hf_ecat_syncman_flag13,
1320 { "SM Flag13", "ecat.syncman_flag13",
1321 FT_BOOLEAN, 32, TFS(&tfs_ecat_syncman_flag13), 0x00002000,
1322 NULL, HFILL }
1323 },
1324 { &hf_ecat_syncman_flag16,
1325 { "SM Flag16", "ecat.syncman_flag16",
1326 FT_BOOLEAN, 32, TFS(&tfs_ecat_syncman_flag16), 0x00010000,
1327 NULL, HFILL }
1328 },
1329 { &hf_ecat_fmmu,
1330 { "FMMU", "ecat.fmmu",
1331 FT_BYTES, BASE_NONE, NULL, 0x0,
1332 NULL, HFILL }
1333 },
1334 { &hf_ecat_fmmu_lstart,
1335 { "Log Start", "ecat.fmmu.lstart",
1336 FT_UINT32, BASE_HEX, NULL, 0x0,
1337 NULL, HFILL }
1338 },
1339 { &hf_ecat_fmmu_llen,
1340 { "Log Length", "ecat.fmmu.llen",
1341 FT_UINT16, BASE_HEX, NULL, 0x0,
1342 NULL, HFILL }
1343 },
1344 { &hf_ecat_fmmu_lstartbit,
1345 { "Log StartBit", "ecat.fmmu.lstartbit",
1346 FT_UINT8, BASE_HEX, NULL, 0x0,
1347 NULL, HFILL }
1348 },
1349 { &hf_ecat_fmmu_lendbit,
1350 { "Log EndBit", "ecat.fmmu.lendbit",
1351 FT_UINT8, BASE_HEX, NULL, 0x0,
1352 NULL, HFILL }
1353 },
1354 { &hf_ecat_fmmu_pstart,
1355 { "Phys Start", "ecat.fmmu.pstart",
1356 FT_UINT8, BASE_HEX, NULL, 0x0,
1357 NULL, HFILL }
1358 },
1359 { &hf_ecat_fmmu_pstartbit,
1360 { "Phys StartBit", "ecat.fmmu.pstartbit",
1361 FT_UINT8, BASE_HEX, NULL, 0x0,
1362 NULL, HFILL }
1363 },
1364 { &hf_ecat_fmmu_type,
1365 { "FMMU Type", "ecat.fmmu.type",
1366 FT_UINT8, BASE_HEX, NULL, 0x0,
1367 NULL, HFILL }
1368 },
1369 { &hf_ecat_fmmu_typeread,
1370 { "Type", "ecat.fmmu.typeread",
1371 FT_BOOLEAN, 8, TFS(&tfs_ecat_fmmu_typeread), 0x01,
1372 NULL, HFILL }
1373 },
1374 { &hf_ecat_fmmu_typewrite,
1375 { "Type", "ecat.fmmu.typewrite",
1376 FT_BOOLEAN, 8, TFS(&tfs_ecat_fmmu_typewrite), 0x02,
1377 NULL, HFILL }
1378 },
1379 { &hf_ecat_fmmu_active,
1380 { "FMMU Active", "ecat.fmmu.active",
1381 FT_UINT8, BASE_HEX, NULL, 0x0,
1382 NULL, HFILL }
1383 },
1384 { &hf_ecat_fmmu_active0,
1385 { "Active", "ecat.fmmu.active0",
1386 FT_BOOLEAN, 8, TFS(&tfs_ecat_fmmu_active), 0x01,
1387 NULL, HFILL }
1388 },
1389 { &hf_ecat_dc_diff_da,
1390 { "DC D-A", "ecat.dc.dif.da",
1391 FT_UINT32, BASE_DEC, NULL, 0x0,
1392 NULL, HFILL }
1393 },
1394 { &hf_ecat_dc_diff_bd,
1395 { "DC B-D", "ecat.dc.dif.bd",
1396 FT_UINT32, BASE_DEC, NULL, 0x0,
1397 NULL, HFILL }
1398 },
1399 { &hf_ecat_dc_diff_cb,
1400 { "DC C-B", "ecat.dc.dif.cb",
1401 FT_UINT32, BASE_DEC, NULL, 0x0,
1402 NULL, HFILL }
1403 },
1404 { &hf_ecat_dc_diff_cd,
1405 { "DC C-D", "ecat.dc.dif.cd",
1406 FT_UINT32, BASE_DEC, NULL, 0x0,
1407 NULL, HFILL }
1408 },
1409 { &hf_ecat_dc_diff_ba,
1410 { "DC B-A", "ecat.dc.dif.ba",
1411 FT_UINT32, BASE_DEC, NULL, 0x0,
1412 NULL, HFILL }
1413 },
1414 { &hf_ecat_dc_diff_ca,
1415 { "DC C-A", "ecat.dc.dif.ca",
1416 FT_UINT32, BASE_DEC, NULL, 0x0,
1417 NULL, HFILL }
1418 },
1419 { &hf_ecat_sub_dc_diff_da[0],
1420 { "DC D-A", "ecat.sub1.dc.dif.da",
1421 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1422 },
1423 { &hf_ecat_sub_dc_diff_da[1],
1424 { "DC D-A", "ecat.sub2.dc.dif.da",
1425 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1426 },
1427 { &hf_ecat_sub_dc_diff_da[2],
1428 { "DC D-A", "ecat.sub3.dc.dif.da",
1429 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1430 },
1431 { &hf_ecat_sub_dc_diff_da[3],
1432 { "DC D-A", "ecat.sub4.dc.dif.da",
1433 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1434 },
1435 { &hf_ecat_sub_dc_diff_da[4],
1436 { "DC D-A", "ecat.sub5.dc.dif.da",
1437 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1438 },
1439 { &hf_ecat_sub_dc_diff_da[5],
1440 { "DC D-A", "ecat.sub6.dc.dif.da",
1441 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1442 },
1443 { &hf_ecat_sub_dc_diff_da[6],
1444 { "DC D-A", "ecat.sub7.dc.dif.da",
1445 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1446 },
1447 { &hf_ecat_sub_dc_diff_da[7],
1448 { "DC D-A", "ecat.sub8.dc.dif.da",
1449 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1450 },
1451 { &hf_ecat_sub_dc_diff_da[8],
1452 { "DC D-A", "ecat.sub9.dc.dif.da",
1453 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1454 },
1455 { &hf_ecat_sub_dc_diff_da[9],
1456 { "DC D-A", "ecat.sub10.dc.dif.da",
1457 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1458 },
1459
1460 { &hf_ecat_sub_dc_diff_bd[0],
1461 { "DC B-C", "ecat.sub1.dc.dif.bd",
1462 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1463 },
1464 { &hf_ecat_sub_dc_diff_bd[1],
1465 { "DC B-C", "ecat.sub2.dc.dif.bd",
1466 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1467 },
1468 { &hf_ecat_sub_dc_diff_bd[2],
1469 { "DC B-C", "ecat.sub3.dc.dif.bd",
1470 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1471 },
1472 { &hf_ecat_sub_dc_diff_bd[3],
1473 { "DC B-C", "ecat.sub4.dc.dif.bd",
1474 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1475 },
1476 { &hf_ecat_sub_dc_diff_bd[4],
1477 { "DC B-C", "ecat.sub5.dc.dif.bd",
1478 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1479 },
1480 { &hf_ecat_sub_dc_diff_bd[5],
1481 { "DC B-C", "ecat.sub6.dc.dif.bd",
1482 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1483 },
1484 { &hf_ecat_sub_dc_diff_bd[6],
1485 { "DC B-C", "ecat.sub7.dc.dif.bd",
1486 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1487 },
1488 { &hf_ecat_sub_dc_diff_bd[7],
1489 { "DC B-C", "ecat.sub8.dc.dif.bd",
1490 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1491 },
1492 { &hf_ecat_sub_dc_diff_bd[8],
1493 { "DC B-C", "ecat.sub9.dc.dif.bd",
1494 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1495 },
1496 { &hf_ecat_sub_dc_diff_bd[9],
1497 { "DC B-D", "ecat.sub10.dc.dif.bd",
1498 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1499 },
1500
1501 { &hf_ecat_sub_dc_diff_cb[0],
1502 { "DC C-B", "ecat.sub1.dc.dif.cb",
1503 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1504 },
1505 { &hf_ecat_sub_dc_diff_cb[1],
1506 { "DC C-B", "ecat.sub2.dc.dif.cb",
1507 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1508 },
1509 { &hf_ecat_sub_dc_diff_cb[2],
1510 { "DC C-B", "ecat.sub3.dc.dif.cb",
1511 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1512 },
1513 { &hf_ecat_sub_dc_diff_cb[3],
1514 { "DC C-B", "ecat.sub4.dc.dif.cb",
1515 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1516 },
1517 { &hf_ecat_sub_dc_diff_cb[4],
1518 { "DC C-B", "ecat.sub5.dc.dif.cb",
1519 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1520 },
1521 { &hf_ecat_sub_dc_diff_cb[5],
1522 { "DC C-B", "ecat.sub6.dc.dif.cb",
1523 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1524 },
1525 { &hf_ecat_sub_dc_diff_cb[6],
1526 { "DC C-B", "ecat.sub7.dc.dif.cb",
1527 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1528 },
1529 { &hf_ecat_sub_dc_diff_cb[7],
1530 { "DC C-B", "ecat.sub8.dc.dif.cb",
1531 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1532 },
1533 { &hf_ecat_sub_dc_diff_cb[8],
1534 { "DC C-B", "ecat.sub9.dc.dif.cb",
1535 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1536 },
1537 { &hf_ecat_sub_dc_diff_cb[9],
1538 { "DC C-B", "ecat.sub10.dc.dif.cb",
1539 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1540 },
1541
1542 { &hf_ecat_sub_dc_diff_cd[0],
1543 { "DC C-D", "ecat.sub1.dc.dif.cd",
1544 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1545 },
1546 { &hf_ecat_sub_dc_diff_cd[1],
1547 { "DC C-D", "ecat.sub2.dc.dif.cd",
1548 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1549 },
1550 { &hf_ecat_sub_dc_diff_cd[2],
1551 { "DC C-D", "ecat.sub3.dc.dif.cd",
1552 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1553 },
1554 { &hf_ecat_sub_dc_diff_cd[3],
1555 { "DC C-D", "ecat.sub4.dc.dif.cd",
1556 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1557 },
1558 { &hf_ecat_sub_dc_diff_cd[4],
1559 { "DC C-D", "ecat.sub5.dc.dif.cd",
1560 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1561 },
1562 { &hf_ecat_sub_dc_diff_cd[5],
1563 { "DC C-D", "ecat.sub6.dc.dif.cd",
1564 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1565 },
1566 { &hf_ecat_sub_dc_diff_cd[6],
1567 { "DC C-D", "ecat.sub7.dc.dif.cd",
1568 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1569 },
1570 { &hf_ecat_sub_dc_diff_cd[7],
1571 { "DC C-D", "ecat.sub8.dc.dif.cd",
1572 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1573 },
1574 { &hf_ecat_sub_dc_diff_cd[8],
1575 { "DC C-D", "ecat.sub9.dc.dif.cd",
1576 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1577 },
1578 { &hf_ecat_sub_dc_diff_cd[9],
1579 { "DC C-D", "ecat.sub10.dc.dif.cd",
1580 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1581 },
1582
1583 { &hf_ecat_sub_dc_diff_ba[0],
1584 { "DC B-A", "ecat.sub1.dc.dif.ba",
1585 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1586 },
1587 { &hf_ecat_sub_dc_diff_ba[1],
1588 { "DC B-A", "ecat.sub2.dc.dif.ba",
1589 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1590 },
1591 { &hf_ecat_sub_dc_diff_ba[2],
1592 { "DC B-A", "ecat.sub3.dc.dif.ba",
1593 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1594 },
1595 { &hf_ecat_sub_dc_diff_ba[3],
1596 { "DC B-A", "ecat.sub4.dc.dif.ba",
1597 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1598 },
1599 { &hf_ecat_sub_dc_diff_ba[4],
1600 { "DC B-A", "ecat.sub5.dc.dif.ba",
1601 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1602 },
1603 { &hf_ecat_sub_dc_diff_ba[5],
1604 { "DC B-A", "ecat.sub6.dc.dif.ba",
1605 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1606 },
1607 { &hf_ecat_sub_dc_diff_ba[6],
1608 { "DC B-A", "ecat.sub7.dc.dif.ba",
1609 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1610 },
1611 { &hf_ecat_sub_dc_diff_ba[7],
1612 { "DC B-A", "ecat.sub8.dc.dif.ba",
1613 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1614 },
1615 { &hf_ecat_sub_dc_diff_ba[8],
1616 { "DC B-A", "ecat.sub9.dc.dif.ba",
1617 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1618 },
1619 { &hf_ecat_sub_dc_diff_ba[9],
1620 { "DC B-A", "ecat.sub10.dc.dif.ba",
1621 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1622 },
1623
1624 { &hf_ecat_sub_dc_diff_ca[0],
1625 { "DC C-A", "ecat.sub1.dc.dif.ca",
1626 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1627 },
1628 { &hf_ecat_sub_dc_diff_ca[1],
1629 { "DC C-A", "ecat.sub2.dc.dif.ca",
1630 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1631 },
1632 { &hf_ecat_sub_dc_diff_ca[2],
1633 { "DC C-A", "ecat.sub3.dc.dif.ca",
1634 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1635 },
1636 { &hf_ecat_sub_dc_diff_ca[3],
1637 { "DC C-A", "ecat.sub4.dc.dif.ca",
1638 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1639 },
1640 { &hf_ecat_sub_dc_diff_ca[4],
1641 { "DC C-A", "ecat.sub5.dc.dif.ca",
1642 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1643 },
1644 { &hf_ecat_sub_dc_diff_ca[5],
1645 { "DC C-A", "ecat.sub6.dc.dif.ca",
1646 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1647 },
1648 { &hf_ecat_sub_dc_diff_ca[6],
1649 { "DC C-A", "ecat.sub7.dc.dif.ca",
1650 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1651 },
1652 { &hf_ecat_sub_dc_diff_ca[7],
1653 { "DC C-A", "ecat.sub8.dc.dif.ca",
1654 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1655 },
1656 { &hf_ecat_sub_dc_diff_ca[8],
1657 { "DC C-A", "ecat.sub9.dc.dif.ca",
1658 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1659 },
1660 { &hf_ecat_sub_dc_diff_ca[9],
1661 { "DC C-A", "ecat.sub10.dc.dif.ca",
1662 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }
1663 },
1664 { &hf_ecat_length_len,
1665 { "Length", "ecat.subframe.length",
1666 FT_UINT16, BASE_DEC, NULL, 0x07ff, NULL, HFILL}
1667 },
1668 { &hf_ecat_length_r,
1669 { "Reserved", "ecat.subframe.reserved",
1670 FT_UINT16, BASE_DEC, VALS(ecat_subframe_reserved_vals), 0x3800, NULL, HFILL}
1671 },
1672 { &hf_ecat_length_c,
1673 { "Round trip", "ecat.subframe.circulating",
1674 FT_UINT16, BASE_DEC, VALS(ecat_subframe_circulating_vals), 0x4000, NULL, HFILL}
1675 },
1676 { &hf_ecat_length_m,
1677 { "Last indicator", "ecat.subframe.more",
1678 FT_UINT16, BASE_DEC, VALS(ecat_subframe_more_vals), 0x8000, NULL, HFILL}
1679 },
1680 { &hf_ecat_padding,
1681 { "Pad bytes", "ecat.subframe.pad_bytes",
1682 FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL}
1683 }
1684 };
1685
1686 static gint *ett[] =
1687 {
1688 &ett_ecat,
1689 &ett_ecat_header,
1690 &ett_ecat_syncman,
1691 &ett_ecat_syncflag,
1692 &ett_ecat_fmmu,
1693 &ett_ecat_fmmu_type,
1694 &ett_ecat_fmmu_active,
1695 &ett_ecat_dc,
1696 &ett_ecat_length,
1697 &ett_ecat_padding,
1698 &ett_ecat_datagram_subtree
1699 };
1700
1701 proto_ecat_datagram = proto_register_protocol("EtherCAT datagram(s)",
1702 "ECAT", "ecat");
1703 proto_register_field_array(proto_ecat_datagram, hf, array_length(hf));
1704 proto_register_subtree_array(ett, array_length(ett));
1705
1706 /* Sub dissector code */
1707 register_heur_dissector_list("ecat.data", &heur_subdissector_list);
1708 }
1709
1710 /* The registration hand-off routing */
1711 void proto_reg_handoff_ecat(void)
1712 {
1713 dissector_handle_t ecat_handle;
1714
1715 /* Register this dissector as a sub dissector to EtherCAT frame based on
1716 ether type. */
1717 ecat_handle = create_dissector_handle(dissect_ecat_datagram, proto_ecat_datagram);
1718 dissector_add_uint("ecatf.type", 1 /* EtherCAT type */, ecat_handle);
1719
1720 ecat_mailbox_handle = find_dissector("ecat_mailbox");
1721 }