IgH EtherCAT Master  1.5.2
master.c
Go to the documentation of this file.
1 /******************************************************************************
2  *
3  * Copyright (C) 2006-2020 Florian Pose, Ingenieurgemeinschaft IgH
4  *
5  * This file is part of the IgH EtherCAT Master.
6  *
7  * The IgH EtherCAT Master is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License version 2, as
9  * published by the Free Software Foundation.
10  *
11  * The IgH EtherCAT Master is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
14  * Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License along
17  * with the IgH EtherCAT Master; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19  *
20  * ---
21  *
22  * The license mentioned above concerns the source code only. Using the
23  * EtherCAT technology and brand is only permitted in compliance with the
24  * industrial property and similar rights of Beckhoff Automation GmbH.
25  *
26  * vim: expandtab
27  *
28  *****************************************************************************/
29 
35 /*****************************************************************************/
36 
37 #include <linux/module.h>
38 #include <linux/kernel.h>
39 #include <linux/string.h>
40 #include <linux/slab.h>
41 #include <linux/delay.h>
42 #include <linux/device.h>
43 #include <linux/version.h>
44 #include <linux/hrtimer.h>
45 
46 #include "globals.h"
47 #include "slave.h"
48 #include "slave_config.h"
49 #include "device.h"
50 #include "datagram.h"
51 
52 #ifdef EC_EOE
53 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0)
54 #include <uapi/linux/sched/types.h> // struct sched_param
55 #include <linux/sched/types.h> // sched_setscheduler
56 #endif
57 #include "ethernet.h"
58 #endif
59 
60 #include "master.h"
61 
62 /*****************************************************************************/
63 
66 #define DEBUG_INJECT 0
67 
70 #define FORCE_OUTPUT_CORRUPTED 0
71 
72 #ifdef EC_HAVE_CYCLES
73 
76 static cycles_t timeout_cycles;
77 
80 static cycles_t ext_injection_timeout_cycles;
81 
82 #else
83 
86 static unsigned long timeout_jiffies;
87 
90 static unsigned long ext_injection_timeout_jiffies;
91 
92 #endif
93 
96 const unsigned int rate_intervals[] = {
97  1, 10, 60
98 };
99 
100 /*****************************************************************************/
101 
102 void ec_master_clear_slave_configs(ec_master_t *);
103 void ec_master_clear_domains(ec_master_t *);
104 static int ec_master_idle_thread(void *);
105 static int ec_master_operation_thread(void *);
106 #ifdef EC_EOE
107 static int ec_master_eoe_thread(void *);
108 #endif
109 void ec_master_find_dc_ref_clock(ec_master_t *);
110 void ec_master_clear_device_stats(ec_master_t *);
111 void ec_master_update_device_stats(ec_master_t *);
112 
113 /*****************************************************************************/
114 
117 void ec_master_init_static(void)
118 {
119 #ifdef EC_HAVE_CYCLES
120  timeout_cycles = (cycles_t) EC_IO_TIMEOUT /* us */ * (cpu_khz / 1000);
121  ext_injection_timeout_cycles =
122  (cycles_t) EC_SDO_INJECTION_TIMEOUT /* us */ * (cpu_khz / 1000);
123 #else
124  // one jiffy may always elapse between time measurement
125  timeout_jiffies = max(EC_IO_TIMEOUT * HZ / 1000000, 1);
126  ext_injection_timeout_jiffies =
127  max(EC_SDO_INJECTION_TIMEOUT * HZ / 1000000, 1);
128 #endif
129 }
130 
131 /*****************************************************************************/
132 
138 int ec_master_init(ec_master_t *master,
139  unsigned int index,
140  const uint8_t *main_mac,
141  const uint8_t *backup_mac,
142  dev_t device_number,
143  struct class *class,
144  unsigned int debug_level
145  )
146 {
147  int ret;
148  unsigned int dev_idx, i;
149 
150  master->index = index;
151  master->reserved = 0;
152 
153  sema_init(&master->master_sem, 1);
154 
155  for (dev_idx = EC_DEVICE_MAIN; dev_idx < EC_MAX_NUM_DEVICES; dev_idx++) {
156  master->macs[dev_idx] = NULL;
157  }
158 
159  master->macs[EC_DEVICE_MAIN] = main_mac;
160 
161 #if EC_MAX_NUM_DEVICES > 1
162  master->macs[EC_DEVICE_BACKUP] = backup_mac;
163  master->num_devices = 1 + !ec_mac_is_zero(backup_mac);
164 #else
165  if (!ec_mac_is_zero(backup_mac)) {
166  EC_MASTER_WARN(master, "Ignoring backup MAC address!");
167  }
168 #endif
169 
170  ec_master_clear_device_stats(master);
171 
172  sema_init(&master->device_sem, 1);
173 
174  master->phase = EC_ORPHANED;
175  master->active = 0;
176  master->config_changed = 0;
177  master->injection_seq_fsm = 0;
178  master->injection_seq_rt = 0;
179 
180  master->slaves = NULL;
181  master->slave_count = 0;
182 
183  INIT_LIST_HEAD(&master->configs);
184  INIT_LIST_HEAD(&master->domains);
185 
186  master->app_time = 0ULL;
187  master->dc_ref_time = 0ULL;
188 
189  master->scan_busy = 0;
190  master->allow_scan = 1;
191  sema_init(&master->scan_sem, 1);
192  init_waitqueue_head(&master->scan_queue);
193 
194  master->config_busy = 0;
195  sema_init(&master->config_sem, 1);
196  init_waitqueue_head(&master->config_queue);
197 
198  INIT_LIST_HEAD(&master->datagram_queue);
199  master->datagram_index = 0;
200 
201  INIT_LIST_HEAD(&master->ext_datagram_queue);
202  sema_init(&master->ext_queue_sem, 1);
203 
204  master->ext_ring_idx_rt = 0;
205  master->ext_ring_idx_fsm = 0;
206 
207  // init external datagram ring
208  for (i = 0; i < EC_EXT_RING_SIZE; i++) {
209  ec_datagram_t *datagram = &master->ext_datagram_ring[i];
210  ec_datagram_init(datagram);
211  snprintf(datagram->name, EC_DATAGRAM_NAME_SIZE, "ext-%u", i);
212  }
213 
214  // send interval in IDLE phase
215  ec_master_set_send_interval(master, 1000000 / HZ);
216 
217  master->fsm_slave = NULL;
218  INIT_LIST_HEAD(&master->fsm_exec_list);
219  master->fsm_exec_count = 0U;
220 
221  master->debug_level = debug_level;
222  master->stats.timeouts = 0;
223  master->stats.corrupted = 0;
224  master->stats.unmatched = 0;
225  master->stats.output_jiffies = 0;
226 
227  master->thread = NULL;
228 
229 #ifdef EC_EOE
230  master->eoe_thread = NULL;
231  INIT_LIST_HEAD(&master->eoe_handlers);
232 #endif
233 
234  sema_init(&master->io_sem, 1);
235  master->send_cb = NULL;
236  master->receive_cb = NULL;
237  master->cb_data = NULL;
238  master->app_send_cb = NULL;
239  master->app_receive_cb = NULL;
240  master->app_cb_data = NULL;
241 
242  INIT_LIST_HEAD(&master->sii_requests);
243  INIT_LIST_HEAD(&master->emerg_reg_requests);
244 
245  init_waitqueue_head(&master->request_queue);
246 
247  // init devices
248  for (dev_idx = EC_DEVICE_MAIN; dev_idx < ec_master_num_devices(master);
249  dev_idx++) {
250  ret = ec_device_init(&master->devices[dev_idx], master);
251  if (ret < 0) {
252  goto out_clear_devices;
253  }
254  }
255 
256  // init state machine datagram
257  ec_datagram_init(&master->fsm_datagram);
258  snprintf(master->fsm_datagram.name, EC_DATAGRAM_NAME_SIZE, "master-fsm");
259  ret = ec_datagram_prealloc(&master->fsm_datagram, EC_MAX_DATA_SIZE);
260  if (ret < 0) {
261  ec_datagram_clear(&master->fsm_datagram);
262  EC_MASTER_ERR(master, "Failed to allocate FSM datagram.\n");
263  goto out_clear_devices;
264  }
265 
266  // create state machine object
267  ec_fsm_master_init(&master->fsm, master, &master->fsm_datagram);
268 
269  // alloc external datagram ring
270  for (i = 0; i < EC_EXT_RING_SIZE; i++) {
271  ec_datagram_t *datagram = &master->ext_datagram_ring[i];
272  ret = ec_datagram_prealloc(datagram, EC_MAX_DATA_SIZE);
273  if (ret) {
274  EC_MASTER_ERR(master, "Failed to allocate external"
275  " datagram %u.\n", i);
276  goto out_clear_ext_datagrams;
277  }
278  }
279 
280  // init reference sync datagram
281  ec_datagram_init(&master->ref_sync_datagram);
282  snprintf(master->ref_sync_datagram.name, EC_DATAGRAM_NAME_SIZE,
283  "refsync");
284  ret = ec_datagram_prealloc(&master->ref_sync_datagram, 4);
285  if (ret < 0) {
286  ec_datagram_clear(&master->ref_sync_datagram);
287  EC_MASTER_ERR(master, "Failed to allocate reference"
288  " synchronisation datagram.\n");
289  goto out_clear_ext_datagrams;
290  }
291 
292  // init sync datagram
293  ec_datagram_init(&master->sync_datagram);
294  snprintf(master->sync_datagram.name, EC_DATAGRAM_NAME_SIZE, "sync");
295  ret = ec_datagram_prealloc(&master->sync_datagram, 4);
296  if (ret < 0) {
297  ec_datagram_clear(&master->sync_datagram);
298  EC_MASTER_ERR(master, "Failed to allocate"
299  " synchronisation datagram.\n");
300  goto out_clear_ref_sync;
301  }
302 
303  // init sync monitor datagram
304  ec_datagram_init(&master->sync_mon_datagram);
305  snprintf(master->sync_mon_datagram.name, EC_DATAGRAM_NAME_SIZE,
306  "syncmon");
307  ret = ec_datagram_brd(&master->sync_mon_datagram, 0x092c, 4);
308  if (ret < 0) {
309  ec_datagram_clear(&master->sync_mon_datagram);
310  EC_MASTER_ERR(master, "Failed to allocate sync"
311  " monitoring datagram.\n");
312  goto out_clear_sync;
313  }
314 
315  master->dc_ref_config = NULL;
316  master->dc_ref_clock = NULL;
317 
318  // init character device
319  ret = ec_cdev_init(&master->cdev, master, device_number);
320  if (ret)
321  goto out_clear_sync_mon;
322 
323 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27)
324  master->class_device = device_create(class, NULL,
325  MKDEV(MAJOR(device_number), master->index), NULL,
326  "EtherCAT%u", master->index);
327 #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26)
328  master->class_device = device_create(class, NULL,
329  MKDEV(MAJOR(device_number), master->index),
330  "EtherCAT%u", master->index);
331 #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 15)
332  master->class_device = class_device_create(class, NULL,
333  MKDEV(MAJOR(device_number), master->index), NULL,
334  "EtherCAT%u", master->index);
335 #else
336  master->class_device = class_device_create(class,
337  MKDEV(MAJOR(device_number), master->index), NULL,
338  "EtherCAT%u", master->index);
339 #endif
340  if (IS_ERR(master->class_device)) {
341  EC_MASTER_ERR(master, "Failed to create class device!\n");
342  ret = PTR_ERR(master->class_device);
343  goto out_clear_cdev;
344  }
345 
346 #ifdef EC_RTDM
347  // init RTDM device
348  ret = ec_rtdm_dev_init(&master->rtdm_dev, master);
349  if (ret) {
350  goto out_unregister_class_device;
351  }
352 #endif
353 
354  return 0;
355 
356 #ifdef EC_RTDM
357 out_unregister_class_device:
358 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26)
359  device_unregister(master->class_device);
360 #else
361  class_device_unregister(master->class_device);
362 #endif
363 #endif
364 out_clear_cdev:
365  ec_cdev_clear(&master->cdev);
366 out_clear_sync_mon:
367  ec_datagram_clear(&master->sync_mon_datagram);
368 out_clear_sync:
369  ec_datagram_clear(&master->sync_datagram);
370 out_clear_ref_sync:
371  ec_datagram_clear(&master->ref_sync_datagram);
372 out_clear_ext_datagrams:
373  for (i = 0; i < EC_EXT_RING_SIZE; i++) {
374  ec_datagram_clear(&master->ext_datagram_ring[i]);
375  }
376  ec_fsm_master_clear(&master->fsm);
377  ec_datagram_clear(&master->fsm_datagram);
378 out_clear_devices:
379  for (; dev_idx > 0; dev_idx--) {
380  ec_device_clear(&master->devices[dev_idx - 1]);
381  }
382  return ret;
383 }
384 
385 /*****************************************************************************/
386 
389 void ec_master_clear(
390  ec_master_t *master
391  )
392 {
393  unsigned int dev_idx, i;
394 
395 #ifdef EC_RTDM
396  ec_rtdm_dev_clear(&master->rtdm_dev);
397 #endif
398 
399 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26)
400  device_unregister(master->class_device);
401 #else
402  class_device_unregister(master->class_device);
403 #endif
404 
405  ec_cdev_clear(&master->cdev);
406 
407 #ifdef EC_EOE
408  ec_master_clear_eoe_handlers(master);
409 #endif
410  ec_master_clear_domains(master);
411  ec_master_clear_slave_configs(master);
412  ec_master_clear_slaves(master);
413 
414  ec_datagram_clear(&master->sync_mon_datagram);
415  ec_datagram_clear(&master->sync_datagram);
416  ec_datagram_clear(&master->ref_sync_datagram);
417 
418  for (i = 0; i < EC_EXT_RING_SIZE; i++) {
419  ec_datagram_clear(&master->ext_datagram_ring[i]);
420  }
421 
422  ec_fsm_master_clear(&master->fsm);
423  ec_datagram_clear(&master->fsm_datagram);
424 
425  for (dev_idx = EC_DEVICE_MAIN; dev_idx < ec_master_num_devices(master);
426  dev_idx++) {
427  ec_device_clear(&master->devices[dev_idx]);
428  }
429 }
430 
431 /*****************************************************************************/
432 
433 #ifdef EC_EOE
434 
436 void ec_master_clear_eoe_handlers(
437  ec_master_t *master
438  )
439 {
440  ec_eoe_t *eoe, *next;
441 
442  list_for_each_entry_safe(eoe, next, &master->eoe_handlers, list) {
443  list_del(&eoe->list);
444  ec_eoe_clear(eoe);
445  kfree(eoe);
446  }
447 }
448 #endif
449 
450 /*****************************************************************************/
451 
454 void ec_master_clear_slave_configs(ec_master_t *master)
455 {
456  ec_slave_config_t *sc, *next;
457 
458  master->dc_ref_config = NULL;
459  master->fsm.sdo_request = NULL; // mark sdo_request as invalid
460 
461  list_for_each_entry_safe(sc, next, &master->configs, list) {
462  list_del(&sc->list);
463  ec_slave_config_clear(sc);
464  kfree(sc);
465  }
466 }
467 
468 /*****************************************************************************/
469 
472 void ec_master_clear_slaves(ec_master_t *master)
473 {
474  ec_slave_t *slave;
475 
476  master->dc_ref_clock = NULL;
477 
478  // External requests are obsolete, so we wake pending waiters and remove
479  // them from the list.
480 
481  while (!list_empty(&master->sii_requests)) {
482  ec_sii_write_request_t *request =
483  list_entry(master->sii_requests.next,
484  ec_sii_write_request_t, list);
485  list_del_init(&request->list); // dequeue
486  EC_MASTER_WARN(master, "Discarding SII request, slave %u about"
487  " to be deleted.\n", request->slave->ring_position);
488  request->state = EC_INT_REQUEST_FAILURE;
489  wake_up_all(&master->request_queue);
490  }
491 
492  master->fsm_slave = NULL;
493  INIT_LIST_HEAD(&master->fsm_exec_list);
494  master->fsm_exec_count = 0;
495 
496  for (slave = master->slaves;
497  slave < master->slaves + master->slave_count;
498  slave++) {
499  ec_slave_clear(slave);
500  }
501 
502  if (master->slaves) {
503  kfree(master->slaves);
504  master->slaves = NULL;
505  }
506 
507  master->slave_count = 0;
508 }
509 
510 /*****************************************************************************/
511 
514 void ec_master_clear_domains(ec_master_t *master)
515 {
516  ec_domain_t *domain, *next;
517 
518  list_for_each_entry_safe(domain, next, &master->domains, list) {
519  list_del(&domain->list);
520  ec_domain_clear(domain);
521  kfree(domain);
522  }
523 }
524 
525 /*****************************************************************************/
526 
529 void ec_master_clear_config(
530  ec_master_t *master
531  )
532 {
533  down(&master->master_sem);
534  ec_master_clear_domains(master);
535  ec_master_clear_slave_configs(master);
536  up(&master->master_sem);
537 }
538 
539 /*****************************************************************************/
540 
543 void ec_master_internal_send_cb(
544  void *cb_data
545  )
546 {
547  ec_master_t *master = (ec_master_t *) cb_data;
548  down(&master->io_sem);
549  ecrt_master_send_ext(master);
550  up(&master->io_sem);
551 }
552 
553 /*****************************************************************************/
554 
557 void ec_master_internal_receive_cb(
558  void *cb_data
559  )
560 {
561  ec_master_t *master = (ec_master_t *) cb_data;
562  down(&master->io_sem);
563  ecrt_master_receive(master);
564  up(&master->io_sem);
565 }
566 
567 /*****************************************************************************/
568 
574 int ec_master_thread_start(
575  ec_master_t *master,
576  int (*thread_func)(void *),
577  const char *name
578  )
579 {
580  EC_MASTER_INFO(master, "Starting %s thread.\n", name);
581  master->thread = kthread_run(thread_func, master, name);
582  if (IS_ERR(master->thread)) {
583  int err = (int) PTR_ERR(master->thread);
584  EC_MASTER_ERR(master, "Failed to start master thread (error %i)!\n",
585  err);
586  master->thread = NULL;
587  return err;
588  }
589 
590  return 0;
591 }
592 
593 /*****************************************************************************/
594 
597 void ec_master_thread_stop(
598  ec_master_t *master
599  )
600 {
601  unsigned long sleep_jiffies;
602 
603  if (!master->thread) {
604  EC_MASTER_WARN(master, "%s(): Already finished!\n", __func__);
605  return;
606  }
607 
608  EC_MASTER_DBG(master, 1, "Stopping master thread.\n");
609 
610  kthread_stop(master->thread);
611  master->thread = NULL;
612  EC_MASTER_INFO(master, "Master thread exited.\n");
613 
614  if (master->fsm_datagram.state != EC_DATAGRAM_SENT) {
615  return;
616  }
617 
618  // wait for FSM datagram
619  sleep_jiffies = max(HZ / 100, 1); // 10 ms, at least 1 jiffy
620  schedule_timeout(sleep_jiffies);
621 }
622 
623 /*****************************************************************************/
624 
629 int ec_master_enter_idle_phase(
630  ec_master_t *master
631  )
632 {
633  int ret;
634  ec_device_index_t dev_idx;
635 
636  EC_MASTER_DBG(master, 1, "ORPHANED -> IDLE.\n");
637 
638  master->send_cb = ec_master_internal_send_cb;
639  master->receive_cb = ec_master_internal_receive_cb;
640  master->cb_data = master;
641 
642  master->phase = EC_IDLE;
643 
644  // reset number of responding slaves to trigger scanning
645  for (dev_idx = EC_DEVICE_MAIN; dev_idx < ec_master_num_devices(master);
646  dev_idx++) {
647  master->fsm.slaves_responding[dev_idx] = 0;
648  }
649 
650  ret = ec_master_thread_start(master, ec_master_idle_thread,
651  "EtherCAT-IDLE");
652  if (ret)
653  master->phase = EC_ORPHANED;
654 
655  return ret;
656 }
657 
658 /*****************************************************************************/
659 
662 void ec_master_leave_idle_phase(ec_master_t *master )
663 {
664  EC_MASTER_DBG(master, 1, "IDLE -> ORPHANED.\n");
665 
666  master->phase = EC_ORPHANED;
667 
668 #ifdef EC_EOE
669  ec_master_eoe_stop(master);
670 #endif
671  ec_master_thread_stop(master);
672 
673  down(&master->master_sem);
674  ec_master_clear_slaves(master);
675  up(&master->master_sem);
676 
677  ec_fsm_master_reset(&master->fsm);
678 }
679 
680 /*****************************************************************************/
681 
686 int ec_master_enter_operation_phase(
687  ec_master_t *master
688  )
689 {
690  int ret = 0;
691  ec_slave_t *slave;
692 #ifdef EC_EOE
693  ec_eoe_t *eoe;
694 #endif
695 
696  EC_MASTER_DBG(master, 1, "IDLE -> OPERATION.\n");
697 
698  down(&master->config_sem);
699  if (master->config_busy) {
700  up(&master->config_sem);
701 
702  // wait for slave configuration to complete
703  ret = wait_event_interruptible(master->config_queue,
704  !master->config_busy);
705  if (ret) {
706  EC_MASTER_INFO(master, "Finishing slave configuration"
707  " interrupted by signal.\n");
708  goto out_return;
709  }
710 
711  EC_MASTER_DBG(master, 1, "Waiting for pending slave"
712  " configuration returned.\n");
713  } else {
714  up(&master->config_sem);
715  }
716 
717  down(&master->scan_sem);
718  master->allow_scan = 0; // 'lock' the slave list
719  if (!master->scan_busy) {
720  up(&master->scan_sem);
721  } else {
722  up(&master->scan_sem);
723 
724  // wait for slave scan to complete
725  ret = wait_event_interruptible(master->scan_queue,
726  !master->scan_busy);
727  if (ret) {
728  EC_MASTER_INFO(master, "Waiting for slave scan"
729  " interrupted by signal.\n");
730  goto out_allow;
731  }
732 
733  EC_MASTER_DBG(master, 1, "Waiting for pending"
734  " slave scan returned.\n");
735  }
736 
737  // set states for all slaves
738  for (slave = master->slaves;
739  slave < master->slaves + master->slave_count;
740  slave++) {
741  ec_slave_request_state(slave, EC_SLAVE_STATE_PREOP);
742  }
743 
744 #ifdef EC_EOE
745  // ... but set EoE slaves to OP
746  list_for_each_entry(eoe, &master->eoe_handlers, list) {
747  if (ec_eoe_is_open(eoe))
748  ec_slave_request_state(eoe->slave, EC_SLAVE_STATE_OP);
749  }
750 #endif
751 
752  master->phase = EC_OPERATION;
753  master->app_send_cb = NULL;
754  master->app_receive_cb = NULL;
755  master->app_cb_data = NULL;
756  return ret;
757 
758 out_allow:
759  master->allow_scan = 1;
760 out_return:
761  return ret;
762 }
763 
764 /*****************************************************************************/
765 
768 void ec_master_leave_operation_phase(
769  ec_master_t *master
770  )
771 {
772  if (master->active) {
773  ecrt_master_deactivate(master); // also clears config
774  } else {
775  ec_master_clear_config(master);
776  }
777 
778  /* Re-allow scanning for IDLE phase. */
779  master->allow_scan = 1;
780 
781  EC_MASTER_DBG(master, 1, "OPERATION -> IDLE.\n");
782 
783  master->phase = EC_IDLE;
784 }
785 
786 /*****************************************************************************/
787 
790 void ec_master_inject_external_datagrams(
791  ec_master_t *master
792  )
793 {
794  ec_datagram_t *datagram;
795  size_t queue_size = 0, new_queue_size = 0;
796 #if DEBUG_INJECT
797  unsigned int datagram_count = 0;
798 #endif
799 
800  if (master->ext_ring_idx_rt == master->ext_ring_idx_fsm) {
801  // nothing to inject
802  return;
803  }
804 
805  list_for_each_entry(datagram, &master->datagram_queue, queue) {
806  if (datagram->state == EC_DATAGRAM_QUEUED) {
807  queue_size += datagram->data_size;
808  }
809  }
810 
811 #if DEBUG_INJECT
812  EC_MASTER_DBG(master, 1, "Injecting datagrams, queue_size=%zu\n",
813  queue_size);
814 #endif
815 
816  while (master->ext_ring_idx_rt != master->ext_ring_idx_fsm) {
817  datagram = &master->ext_datagram_ring[master->ext_ring_idx_rt];
818 
819  if (datagram->state != EC_DATAGRAM_INIT) {
820  // skip datagram
821  master->ext_ring_idx_rt =
822  (master->ext_ring_idx_rt + 1) % EC_EXT_RING_SIZE;
823  continue;
824  }
825 
826  new_queue_size = queue_size + datagram->data_size;
827  if (new_queue_size <= master->max_queue_size) {
828 #if DEBUG_INJECT
829  EC_MASTER_DBG(master, 1, "Injecting datagram %s"
830  " size=%zu, queue_size=%zu\n", datagram->name,
831  datagram->data_size, new_queue_size);
832  datagram_count++;
833 #endif
834 #ifdef EC_HAVE_CYCLES
835  datagram->cycles_sent = 0;
836 #endif
837  datagram->jiffies_sent = 0;
838  ec_master_queue_datagram(master, datagram);
839  queue_size = new_queue_size;
840  }
841  else if (datagram->data_size > master->max_queue_size) {
842  datagram->state = EC_DATAGRAM_ERROR;
843  EC_MASTER_ERR(master, "External datagram %s is too large,"
844  " size=%zu, max_queue_size=%zu\n",
845  datagram->name, datagram->data_size,
846  master->max_queue_size);
847  }
848  else { // datagram does not fit in the current cycle
849 #ifdef EC_HAVE_CYCLES
850  cycles_t cycles_now = get_cycles();
851 
852  if (cycles_now - datagram->cycles_sent
853  > ext_injection_timeout_cycles)
854 #else
855  if (jiffies - datagram->jiffies_sent
856  > ext_injection_timeout_jiffies)
857 #endif
858  {
859 #if defined EC_RT_SYSLOG || DEBUG_INJECT
860  unsigned int time_us;
861 #endif
862 
863  datagram->state = EC_DATAGRAM_ERROR;
864 
865 #if defined EC_RT_SYSLOG || DEBUG_INJECT
866 #ifdef EC_HAVE_CYCLES
867  time_us = (unsigned int)
868  ((cycles_now - datagram->cycles_sent) * 1000LL)
869  / cpu_khz;
870 #else
871  time_us = (unsigned int)
872  ((jiffies - datagram->jiffies_sent) * 1000000 / HZ);
873 #endif
874  EC_MASTER_ERR(master, "Timeout %u us: Injecting"
875  " external datagram %s size=%zu,"
876  " max_queue_size=%zu\n", time_us, datagram->name,
877  datagram->data_size, master->max_queue_size);
878 #endif
879  }
880  else {
881 #if DEBUG_INJECT
882  EC_MASTER_DBG(master, 1, "Deferred injecting"
883  " external datagram %s size=%u, queue_size=%u\n",
884  datagram->name, datagram->data_size, queue_size);
885 #endif
886  break;
887  }
888  }
889 
890  master->ext_ring_idx_rt =
891  (master->ext_ring_idx_rt + 1) % EC_EXT_RING_SIZE;
892  }
893 
894 #if DEBUG_INJECT
895  EC_MASTER_DBG(master, 1, "Injected %u datagrams.\n", datagram_count);
896 #endif
897 }
898 
899 /*****************************************************************************/
900 
904 void ec_master_set_send_interval(
905  ec_master_t *master,
906  unsigned int send_interval
907  )
908 {
909  master->send_interval = send_interval;
910  master->max_queue_size =
911  (send_interval * 1000) / EC_BYTE_TRANSMISSION_TIME_NS;
912  master->max_queue_size -= master->max_queue_size / 10;
913 }
914 
915 /*****************************************************************************/
916 
921 ec_datagram_t *ec_master_get_external_datagram(
922  ec_master_t *master
923  )
924 {
925  if ((master->ext_ring_idx_fsm + 1) % EC_EXT_RING_SIZE !=
926  master->ext_ring_idx_rt) {
927  ec_datagram_t *datagram =
928  &master->ext_datagram_ring[master->ext_ring_idx_fsm];
929  return datagram;
930  }
931  else {
932  return NULL;
933  }
934 }
935 
936 /*****************************************************************************/
937 
940 void ec_master_queue_datagram(
941  ec_master_t *master,
942  ec_datagram_t *datagram
943  )
944 {
945  ec_datagram_t *queued_datagram;
946 
947  /* It is possible, that a datagram in the queue is re-initialized with the
948  * ec_datagram_<type>() methods and then shall be queued with this method.
949  * In that case, the state is already reset to EC_DATAGRAM_INIT. Check if
950  * the datagram is queued to avoid duplicate queuing (which results in an
951  * infinite loop!). Set the state to EC_DATAGRAM_QUEUED again, probably
952  * causing an unmatched datagram. */
953  list_for_each_entry(queued_datagram, &master->datagram_queue, queue) {
954  if (queued_datagram == datagram) {
955  datagram->skip_count++;
956 #ifdef EC_RT_SYSLOG
957  EC_MASTER_DBG(master, 1,
958  "Datagram %p already queued (skipping).\n", datagram);
959 #endif
960  datagram->state = EC_DATAGRAM_QUEUED;
961  return;
962  }
963  }
964 
965  list_add_tail(&datagram->queue, &master->datagram_queue);
966  datagram->state = EC_DATAGRAM_QUEUED;
967 }
968 
969 /*****************************************************************************/
970 
973 void ec_master_queue_datagram_ext(
974  ec_master_t *master,
975  ec_datagram_t *datagram
976  )
977 {
978  down(&master->ext_queue_sem);
979  list_add_tail(&datagram->queue, &master->ext_datagram_queue);
980  up(&master->ext_queue_sem);
981 }
982 
983 /*****************************************************************************/
984 
988 void ec_master_send_datagrams(
989  ec_master_t *master,
990  ec_device_index_t device_index
991  )
992 {
993  ec_datagram_t *datagram, *next;
994  size_t datagram_size;
995  uint8_t *frame_data, *cur_data = NULL;
996  void *follows_word;
997 #ifdef EC_HAVE_CYCLES
998  cycles_t cycles_start, cycles_sent, cycles_end;
999 #endif
1000  unsigned long jiffies_sent;
1001  unsigned int frame_count, more_datagrams_waiting;
1002  struct list_head sent_datagrams;
1003 
1004 #ifdef EC_HAVE_CYCLES
1005  cycles_start = get_cycles();
1006 #endif
1007  frame_count = 0;
1008  INIT_LIST_HEAD(&sent_datagrams);
1009 
1010  EC_MASTER_DBG(master, 2, "%s(device_index = %u)\n",
1011  __func__, device_index);
1012 
1013  do {
1014  frame_data = NULL;
1015  follows_word = NULL;
1016  more_datagrams_waiting = 0;
1017 
1018  // fill current frame with datagrams
1019  list_for_each_entry(datagram, &master->datagram_queue, queue) {
1020  if (datagram->state != EC_DATAGRAM_QUEUED ||
1021  datagram->device_index != device_index) {
1022  continue;
1023  }
1024 
1025  if (!frame_data) {
1026  // fetch pointer to transmit socket buffer
1027  frame_data =
1028  ec_device_tx_data(&master->devices[device_index]);
1029  cur_data = frame_data + EC_FRAME_HEADER_SIZE;
1030  }
1031 
1032  // does the current datagram fit in the frame?
1033  datagram_size = EC_DATAGRAM_HEADER_SIZE + datagram->data_size
1034  + EC_DATAGRAM_FOOTER_SIZE;
1035  if (cur_data - frame_data + datagram_size > ETH_DATA_LEN) {
1036  more_datagrams_waiting = 1;
1037  break;
1038  }
1039 
1040  list_add_tail(&datagram->sent, &sent_datagrams);
1041  datagram->index = master->datagram_index++;
1042 
1043  EC_MASTER_DBG(master, 2, "Adding datagram 0x%02X\n",
1044  datagram->index);
1045 
1046  // set "datagram following" flag in previous datagram
1047  if (follows_word) {
1048  EC_WRITE_U16(follows_word,
1049  EC_READ_U16(follows_word) | 0x8000);
1050  }
1051 
1052  // EtherCAT datagram header
1053  EC_WRITE_U8 (cur_data, datagram->type);
1054  EC_WRITE_U8 (cur_data + 1, datagram->index);
1055  memcpy(cur_data + 2, datagram->address, EC_ADDR_LEN);
1056  EC_WRITE_U16(cur_data + 6, datagram->data_size & 0x7FF);
1057  EC_WRITE_U16(cur_data + 8, 0x0000);
1058  follows_word = cur_data + 6;
1059  cur_data += EC_DATAGRAM_HEADER_SIZE;
1060 
1061  // EtherCAT datagram data
1062  memcpy(cur_data, datagram->data, datagram->data_size);
1063  cur_data += datagram->data_size;
1064 
1065  // EtherCAT datagram footer
1066  EC_WRITE_U16(cur_data, 0x0000); // reset working counter
1067  cur_data += EC_DATAGRAM_FOOTER_SIZE;
1068  }
1069 
1070  if (list_empty(&sent_datagrams)) {
1071  EC_MASTER_DBG(master, 2, "nothing to send.\n");
1072  break;
1073  }
1074 
1075  // EtherCAT frame header
1076  EC_WRITE_U16(frame_data, ((cur_data - frame_data
1077  - EC_FRAME_HEADER_SIZE) & 0x7FF) | 0x1000);
1078 
1079  // pad frame
1080  while (cur_data - frame_data < ETH_ZLEN - ETH_HLEN)
1081  EC_WRITE_U8(cur_data++, 0x00);
1082 
1083  EC_MASTER_DBG(master, 2, "frame size: %zu\n", cur_data - frame_data);
1084 
1085  // send frame
1086  ec_device_send(&master->devices[device_index],
1087  cur_data - frame_data);
1088 #ifdef EC_HAVE_CYCLES
1089  cycles_sent = get_cycles();
1090 #endif
1091  jiffies_sent = jiffies;
1092 
1093  // set datagram states and sending timestamps
1094  list_for_each_entry_safe(datagram, next, &sent_datagrams, sent) {
1095  datagram->state = EC_DATAGRAM_SENT;
1096 #ifdef EC_HAVE_CYCLES
1097  datagram->cycles_sent = cycles_sent;
1098 #endif
1099  datagram->jiffies_sent = jiffies_sent;
1100  list_del_init(&datagram->sent); // empty list of sent datagrams
1101  }
1102 
1103  frame_count++;
1104  }
1105  while (more_datagrams_waiting);
1106 
1107 #ifdef EC_HAVE_CYCLES
1108  if (unlikely(master->debug_level > 1)) {
1109  cycles_end = get_cycles();
1110  EC_MASTER_DBG(master, 0, "%s()"
1111  " sent %u frames in %uus.\n", __func__, frame_count,
1112  (unsigned int) (cycles_end - cycles_start) * 1000 / cpu_khz);
1113  }
1114 #endif
1115 }
1116 
1117 /*****************************************************************************/
1118 
1125 void ec_master_receive_datagrams(
1126  ec_master_t *master,
1127  ec_device_t *device,
1128  const uint8_t *frame_data,
1129  size_t size
1130  )
1131 {
1132  size_t frame_size, data_size;
1133  uint8_t datagram_type, datagram_index;
1134  unsigned int cmd_follows, matched;
1135  const uint8_t *cur_data;
1136  ec_datagram_t *datagram;
1137 
1138  if (unlikely(size < EC_FRAME_HEADER_SIZE)) {
1139  if (master->debug_level || FORCE_OUTPUT_CORRUPTED) {
1140  EC_MASTER_DBG(master, 0, "Corrupted frame received"
1141  " on %s (size %zu < %u byte):\n",
1142  device->dev->name, size, EC_FRAME_HEADER_SIZE);
1143  ec_print_data(frame_data, size);
1144  }
1145  master->stats.corrupted++;
1146 #ifdef EC_RT_SYSLOG
1147  ec_master_output_stats(master);
1148 #endif
1149  return;
1150  }
1151 
1152  cur_data = frame_data;
1153 
1154  // check length of entire frame
1155  frame_size = EC_READ_U16(cur_data) & 0x07FF;
1156  cur_data += EC_FRAME_HEADER_SIZE;
1157 
1158  if (unlikely(frame_size > size)) {
1159  if (master->debug_level || FORCE_OUTPUT_CORRUPTED) {
1160  EC_MASTER_DBG(master, 0, "Corrupted frame received"
1161  " on %s (invalid frame size %zu for "
1162  "received size %zu):\n", device->dev->name,
1163  frame_size, size);
1164  ec_print_data(frame_data, size);
1165  }
1166  master->stats.corrupted++;
1167 #ifdef EC_RT_SYSLOG
1168  ec_master_output_stats(master);
1169 #endif
1170  return;
1171  }
1172 
1173  cmd_follows = 1;
1174  while (cmd_follows) {
1175  // process datagram header
1176  datagram_type = EC_READ_U8 (cur_data);
1177  datagram_index = EC_READ_U8 (cur_data + 1);
1178  data_size = EC_READ_U16(cur_data + 6) & 0x07FF;
1179  cmd_follows = EC_READ_U16(cur_data + 6) & 0x8000;
1180  cur_data += EC_DATAGRAM_HEADER_SIZE;
1181 
1182  if (unlikely(cur_data - frame_data
1183  + data_size + EC_DATAGRAM_FOOTER_SIZE > size)) {
1184  if (master->debug_level || FORCE_OUTPUT_CORRUPTED) {
1185  EC_MASTER_DBG(master, 0, "Corrupted frame received"
1186  " on %s (invalid data size %zu):\n",
1187  device->dev->name, data_size);
1188  ec_print_data(frame_data, size);
1189  }
1190  master->stats.corrupted++;
1191 #ifdef EC_RT_SYSLOG
1192  ec_master_output_stats(master);
1193 #endif
1194  return;
1195  }
1196 
1197  // search for matching datagram in the queue
1198  matched = 0;
1199  list_for_each_entry(datagram, &master->datagram_queue, queue) {
1200  if (datagram->index == datagram_index
1201  && datagram->state == EC_DATAGRAM_SENT
1202  && datagram->type == datagram_type
1203  && datagram->data_size == data_size) {
1204  matched = 1;
1205  break;
1206  }
1207  }
1208 
1209  // no matching datagram was found
1210  if (!matched) {
1211  master->stats.unmatched++;
1212 #ifdef EC_RT_SYSLOG
1213  ec_master_output_stats(master);
1214 #endif
1215 
1216  if (unlikely(master->debug_level > 0)) {
1217  EC_MASTER_DBG(master, 0, "UNMATCHED datagram:\n");
1218  ec_print_data(cur_data - EC_DATAGRAM_HEADER_SIZE,
1219  EC_DATAGRAM_HEADER_SIZE + data_size
1220  + EC_DATAGRAM_FOOTER_SIZE);
1221 #ifdef EC_DEBUG_RING
1222  ec_device_debug_ring_print(&master->devices[EC_DEVICE_MAIN]);
1223 #endif
1224  }
1225 
1226  cur_data += data_size + EC_DATAGRAM_FOOTER_SIZE;
1227  continue;
1228  }
1229 
1230  if (datagram->type != EC_DATAGRAM_APWR &&
1231  datagram->type != EC_DATAGRAM_FPWR &&
1232  datagram->type != EC_DATAGRAM_BWR &&
1233  datagram->type != EC_DATAGRAM_LWR) {
1234  // copy received data into the datagram memory,
1235  // if something has been read
1236  memcpy(datagram->data, cur_data, data_size);
1237  }
1238  cur_data += data_size;
1239 
1240  // set the datagram's working counter
1241  datagram->working_counter = EC_READ_U16(cur_data);
1242  cur_data += EC_DATAGRAM_FOOTER_SIZE;
1243 
1244  // dequeue the received datagram
1245  datagram->state = EC_DATAGRAM_RECEIVED;
1246 #ifdef EC_HAVE_CYCLES
1247  datagram->cycles_received =
1248  master->devices[EC_DEVICE_MAIN].cycles_poll;
1249 #endif
1250  datagram->jiffies_received =
1251  master->devices[EC_DEVICE_MAIN].jiffies_poll;
1252  list_del_init(&datagram->queue);
1253  }
1254 }
1255 
1256 /*****************************************************************************/
1257 
1263 void ec_master_output_stats(ec_master_t *master )
1264 {
1265  if (unlikely(jiffies - master->stats.output_jiffies >= HZ)) {
1266  master->stats.output_jiffies = jiffies;
1267 
1268  if (master->stats.timeouts) {
1269  EC_MASTER_WARN(master, "%u datagram%s TIMED OUT!\n",
1270  master->stats.timeouts,
1271  master->stats.timeouts == 1 ? "" : "s");
1272  master->stats.timeouts = 0;
1273  }
1274  if (master->stats.corrupted) {
1275  EC_MASTER_WARN(master, "%u frame%s CORRUPTED!\n",
1276  master->stats.corrupted,
1277  master->stats.corrupted == 1 ? "" : "s");
1278  master->stats.corrupted = 0;
1279  }
1280  if (master->stats.unmatched) {
1281  EC_MASTER_WARN(master, "%u datagram%s UNMATCHED!\n",
1282  master->stats.unmatched,
1283  master->stats.unmatched == 1 ? "" : "s");
1284  master->stats.unmatched = 0;
1285  }
1286  }
1287 }
1288 
1289 /*****************************************************************************/
1290 
1293 void ec_master_clear_device_stats(
1294  ec_master_t *master
1295  )
1296 {
1297  unsigned int i;
1298 
1299  // zero frame statistics
1300  master->device_stats.tx_count = 0;
1301  master->device_stats.last_tx_count = 0;
1302  master->device_stats.rx_count = 0;
1303  master->device_stats.last_rx_count = 0;
1304  master->device_stats.tx_bytes = 0;
1305  master->device_stats.last_tx_bytes = 0;
1306  master->device_stats.rx_bytes = 0;
1307  master->device_stats.last_rx_bytes = 0;
1308  master->device_stats.last_loss = 0;
1309 
1310  for (i = 0; i < EC_RATE_COUNT; i++) {
1311  master->device_stats.tx_frame_rates[i] = 0;
1312  master->device_stats.rx_frame_rates[i] = 0;
1313  master->device_stats.tx_byte_rates[i] = 0;
1314  master->device_stats.rx_byte_rates[i] = 0;
1315  master->device_stats.loss_rates[i] = 0;
1316  }
1317 
1318  master->device_stats.jiffies = 0;
1319 }
1320 
1321 /*****************************************************************************/
1322 
1325 void ec_master_update_device_stats(
1326  ec_master_t *master
1327  )
1328 {
1329  ec_device_stats_t *s = &master->device_stats;
1330  s32 tx_frame_rate, rx_frame_rate, tx_byte_rate, rx_byte_rate, loss_rate;
1331  u64 loss;
1332  unsigned int i, dev_idx;
1333 
1334  // frame statistics
1335  if (likely(jiffies - s->jiffies < HZ)) {
1336  return;
1337  }
1338 
1339  tx_frame_rate = (s->tx_count - s->last_tx_count) * 1000;
1340  rx_frame_rate = (s->rx_count - s->last_rx_count) * 1000;
1341  tx_byte_rate = s->tx_bytes - s->last_tx_bytes;
1342  rx_byte_rate = s->rx_bytes - s->last_rx_bytes;
1343  loss = s->tx_count - s->rx_count;
1344  loss_rate = (loss - s->last_loss) * 1000;
1345 
1346  /* Low-pass filter:
1347  * Y_n = y_(n - 1) + T / tau * (x - y_(n - 1)) | T = 1
1348  * -> Y_n += (x - y_(n - 1)) / tau
1349  */
1350  for (i = 0; i < EC_RATE_COUNT; i++) {
1351  s32 n = rate_intervals[i];
1352  s->tx_frame_rates[i] += (tx_frame_rate - s->tx_frame_rates[i]) / n;
1353  s->rx_frame_rates[i] += (rx_frame_rate - s->rx_frame_rates[i]) / n;
1354  s->tx_byte_rates[i] += (tx_byte_rate - s->tx_byte_rates[i]) / n;
1355  s->rx_byte_rates[i] += (rx_byte_rate - s->rx_byte_rates[i]) / n;
1356  s->loss_rates[i] += (loss_rate - s->loss_rates[i]) / n;
1357  }
1358 
1359  s->last_tx_count = s->tx_count;
1360  s->last_rx_count = s->rx_count;
1361  s->last_tx_bytes = s->tx_bytes;
1362  s->last_rx_bytes = s->rx_bytes;
1363  s->last_loss = loss;
1364 
1365  for (dev_idx = EC_DEVICE_MAIN; dev_idx < ec_master_num_devices(master);
1366  dev_idx++) {
1367  ec_device_update_stats(&master->devices[dev_idx]);
1368  }
1369 
1370  s->jiffies = jiffies;
1371 }
1372 
1373 /*****************************************************************************/
1374 
1375 #ifdef EC_USE_HRTIMER
1376 
1377 /*
1378  * Sleep related functions:
1379  */
1380 static enum hrtimer_restart ec_master_nanosleep_wakeup(struct hrtimer *timer)
1381 {
1382  struct hrtimer_sleeper *t =
1383  container_of(timer, struct hrtimer_sleeper, timer);
1384  struct task_struct *task = t->task;
1385 
1386  t->task = NULL;
1387  if (task)
1388  wake_up_process(task);
1389 
1390  return HRTIMER_NORESTART;
1391 }
1392 
1393 /*****************************************************************************/
1394 
1395 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
1396 
1397 /* compatibility with new hrtimer interface */
1398 static inline ktime_t hrtimer_get_expires(const struct hrtimer *timer)
1399 {
1400  return timer->expires;
1401 }
1402 
1403 /*****************************************************************************/
1404 
1405 static inline void hrtimer_set_expires(struct hrtimer *timer, ktime_t time)
1406 {
1407  timer->expires = time;
1408 }
1409 
1410 #endif
1411 
1412 /*****************************************************************************/
1413 
1414 void ec_master_nanosleep(const unsigned long nsecs)
1415 {
1416  struct hrtimer_sleeper t;
1417  enum hrtimer_mode mode = HRTIMER_MODE_REL;
1418 
1419  hrtimer_init(&t.timer, CLOCK_MONOTONIC, mode);
1420  t.timer.function = ec_master_nanosleep_wakeup;
1421  t.task = current;
1422 #ifdef CONFIG_HIGH_RES_TIMERS
1423 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 24)
1424  t.timer.cb_mode = HRTIMER_CB_IRQSAFE_NO_RESTART;
1425 #elif LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 26)
1426  t.timer.cb_mode = HRTIMER_CB_IRQSAFE_NO_SOFTIRQ;
1427 #elif LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 28)
1428  t.timer.cb_mode = HRTIMER_CB_IRQSAFE_UNLOCKED;
1429 #endif
1430 #endif
1431  hrtimer_set_expires(&t.timer, ktime_set(0, nsecs));
1432 
1433  do {
1434  set_current_state(TASK_INTERRUPTIBLE);
1435  hrtimer_start(&t.timer, hrtimer_get_expires(&t.timer), mode);
1436 
1437  if (likely(t.task))
1438  schedule();
1439 
1440  hrtimer_cancel(&t.timer);
1441  mode = HRTIMER_MODE_ABS;
1442 
1443  } while (t.task && !signal_pending(current));
1444 }
1445 
1446 #endif // EC_USE_HRTIMER
1447 
1448 /*****************************************************************************/
1449 
1450 /* compatibility for priority changes */
1451 static inline void set_normal_priority(struct task_struct *p, int nice)
1452 {
1453 #if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 9, 0)
1454  sched_set_normal(p, nice);
1455 #else
1456  struct sched_param param = { .sched_priority = 0 };
1457  sched_setscheduler(p, SCHED_NORMAL, &param);
1458  set_user_nice(p, nice);
1459 #endif
1460 }
1461 
1462 /*****************************************************************************/
1463 
1466 void ec_master_exec_slave_fsms(
1467  ec_master_t *master
1468  )
1469 {
1470  ec_datagram_t *datagram;
1471  ec_fsm_slave_t *fsm, *next;
1472  unsigned int count = 0;
1473 
1474  list_for_each_entry_safe(fsm, next, &master->fsm_exec_list, list) {
1475  if (!fsm->datagram) {
1476  EC_MASTER_WARN(master, "Slave %u FSM has zero datagram."
1477  "This is a bug!\n", fsm->slave->ring_position);
1478  list_del_init(&fsm->list);
1479  master->fsm_exec_count--;
1480  return;
1481  }
1482 
1483  if (fsm->datagram->state == EC_DATAGRAM_INIT ||
1484  fsm->datagram->state == EC_DATAGRAM_QUEUED ||
1485  fsm->datagram->state == EC_DATAGRAM_SENT) {
1486  // previous datagram was not sent or received yet.
1487  // wait until next thread execution
1488  return;
1489  }
1490 
1491  datagram = ec_master_get_external_datagram(master);
1492  if (!datagram) {
1493  // no free datagrams at the moment
1494  EC_MASTER_WARN(master, "No free datagram during"
1495  " slave FSM execution. This is a bug!\n");
1496  continue;
1497  }
1498 
1499 #if DEBUG_INJECT
1500  EC_MASTER_DBG(master, 1, "Executing slave %u FSM.\n",
1501  fsm->slave->ring_position);
1502 #endif
1503  if (ec_fsm_slave_exec(fsm, datagram)) {
1504  // FSM consumed datagram
1505 #if DEBUG_INJECT
1506  EC_MASTER_DBG(master, 1, "FSM consumed datagram %s\n",
1507  datagram->name);
1508 #endif
1509  master->ext_ring_idx_fsm =
1510  (master->ext_ring_idx_fsm + 1) % EC_EXT_RING_SIZE;
1511  }
1512  else {
1513  // FSM finished
1514  list_del_init(&fsm->list);
1515  master->fsm_exec_count--;
1516 #if DEBUG_INJECT
1517  EC_MASTER_DBG(master, 1, "FSM finished. %u remaining.\n",
1518  master->fsm_exec_count);
1519 #endif
1520  }
1521  }
1522 
1523  while (master->fsm_exec_count < EC_EXT_RING_SIZE / 2
1524  && count < master->slave_count) {
1525 
1526  if (ec_fsm_slave_is_ready(&master->fsm_slave->fsm)) {
1527  datagram = ec_master_get_external_datagram(master);
1528 
1529  if (ec_fsm_slave_exec(&master->fsm_slave->fsm, datagram)) {
1530  master->ext_ring_idx_fsm =
1531  (master->ext_ring_idx_fsm + 1) % EC_EXT_RING_SIZE;
1532  list_add_tail(&master->fsm_slave->fsm.list,
1533  &master->fsm_exec_list);
1534  master->fsm_exec_count++;
1535 #if DEBUG_INJECT
1536  EC_MASTER_DBG(master, 1, "New slave %u FSM"
1537  " consumed datagram %s, now %u FSMs in list.\n",
1538  master->fsm_slave->ring_position, datagram->name,
1539  master->fsm_exec_count);
1540 #endif
1541  }
1542  }
1543 
1544  master->fsm_slave++;
1545  if (master->fsm_slave >= master->slaves + master->slave_count) {
1546  master->fsm_slave = master->slaves;
1547  }
1548  count++;
1549  }
1550 }
1551 
1552 /*****************************************************************************/
1553 
1556 static int ec_master_idle_thread(void *priv_data)
1557 {
1558  ec_master_t *master = (ec_master_t *) priv_data;
1559  int fsm_exec;
1560 #ifdef EC_USE_HRTIMER
1561  size_t sent_bytes;
1562 #endif
1563 
1564  // send interval in IDLE phase
1565  ec_master_set_send_interval(master, 1000000 / HZ);
1566 
1567  EC_MASTER_DBG(master, 1, "Idle thread running with send interval = %u us,"
1568  " max data size=%zu\n", master->send_interval,
1569  master->max_queue_size);
1570 
1571  while (!kthread_should_stop()) {
1572  ec_datagram_output_stats(&master->fsm_datagram);
1573 
1574  // receive
1575  down(&master->io_sem);
1576  ecrt_master_receive(master);
1577  up(&master->io_sem);
1578 
1579  // execute master & slave state machines
1580  if (down_interruptible(&master->master_sem)) {
1581  break;
1582  }
1583 
1584  fsm_exec = ec_fsm_master_exec(&master->fsm);
1585 
1586  ec_master_exec_slave_fsms(master);
1587 
1588  up(&master->master_sem);
1589 
1590  // queue and send
1591  down(&master->io_sem);
1592  if (fsm_exec) {
1593  ec_master_queue_datagram(master, &master->fsm_datagram);
1594  }
1595  ecrt_master_send(master);
1596 #ifdef EC_USE_HRTIMER
1597  sent_bytes = master->devices[EC_DEVICE_MAIN].tx_skb[
1598  master->devices[EC_DEVICE_MAIN].tx_ring_index]->len;
1599 #endif
1600  up(&master->io_sem);
1601 
1602  if (ec_fsm_master_idle(&master->fsm)) {
1603 #ifdef EC_USE_HRTIMER
1604  ec_master_nanosleep(master->send_interval * 1000);
1605 #else
1606  set_current_state(TASK_INTERRUPTIBLE);
1607  schedule_timeout(1);
1608 #endif
1609  } else {
1610 #ifdef EC_USE_HRTIMER
1611  ec_master_nanosleep(sent_bytes * EC_BYTE_TRANSMISSION_TIME_NS);
1612 #else
1613  schedule();
1614 #endif
1615  }
1616  }
1617 
1618  EC_MASTER_DBG(master, 1, "Master IDLE thread exiting...\n");
1619 
1620  return 0;
1621 }
1622 
1623 /*****************************************************************************/
1624 
1627 static int ec_master_operation_thread(void *priv_data)
1628 {
1629  ec_master_t *master = (ec_master_t *) priv_data;
1630 
1631  EC_MASTER_DBG(master, 1, "Operation thread running"
1632  " with fsm interval = %u us, max data size=%zu\n",
1633  master->send_interval, master->max_queue_size);
1634 
1635  while (!kthread_should_stop()) {
1636  ec_datagram_output_stats(&master->fsm_datagram);
1637 
1638  if (master->injection_seq_rt == master->injection_seq_fsm) {
1639  // output statistics
1640  ec_master_output_stats(master);
1641 
1642  // execute master & slave state machines
1643  if (down_interruptible(&master->master_sem)) {
1644  break;
1645  }
1646 
1647  if (ec_fsm_master_exec(&master->fsm)) {
1648  // Inject datagrams (let the RT thread queue them, see
1649  // ecrt_master_send())
1650  master->injection_seq_fsm++;
1651  }
1652 
1653  ec_master_exec_slave_fsms(master);
1654 
1655  up(&master->master_sem);
1656  }
1657 
1658 #ifdef EC_USE_HRTIMER
1659  // the op thread should not work faster than the sending RT thread
1660  ec_master_nanosleep(master->send_interval * 1000);
1661 #else
1662  if (ec_fsm_master_idle(&master->fsm)) {
1663  set_current_state(TASK_INTERRUPTIBLE);
1664  schedule_timeout(1);
1665  }
1666  else {
1667  schedule();
1668  }
1669 #endif
1670  }
1671 
1672  EC_MASTER_DBG(master, 1, "Master OP thread exiting...\n");
1673  return 0;
1674 }
1675 
1676 /*****************************************************************************/
1677 
1678 #ifdef EC_EOE
1679 
1681 void ec_master_eoe_start(ec_master_t *master )
1682 {
1683  if (master->eoe_thread) {
1684  EC_MASTER_WARN(master, "EoE already running!\n");
1685  return;
1686  }
1687 
1688  if (list_empty(&master->eoe_handlers))
1689  return;
1690 
1691  if (!master->send_cb || !master->receive_cb) {
1692  EC_MASTER_WARN(master, "No EoE processing"
1693  " because of missing callbacks!\n");
1694  return;
1695  }
1696 
1697  EC_MASTER_INFO(master, "Starting EoE thread.\n");
1698  master->eoe_thread = kthread_run(ec_master_eoe_thread, master,
1699  "EtherCAT-EoE");
1700  if (IS_ERR(master->eoe_thread)) {
1701  int err = (int) PTR_ERR(master->eoe_thread);
1702  EC_MASTER_ERR(master, "Failed to start EoE thread (error %i)!\n",
1703  err);
1704  master->eoe_thread = NULL;
1705  return;
1706  }
1707 
1708  set_normal_priority(master->eoe_thread, 0);
1709 }
1710 
1711 /*****************************************************************************/
1712 
1715 void ec_master_eoe_stop(ec_master_t *master )
1716 {
1717  if (master->eoe_thread) {
1718  EC_MASTER_INFO(master, "Stopping EoE thread.\n");
1719 
1720  kthread_stop(master->eoe_thread);
1721  master->eoe_thread = NULL;
1722  EC_MASTER_INFO(master, "EoE thread exited.\n");
1723  }
1724 }
1725 
1726 /*****************************************************************************/
1727 
1730 static int ec_master_eoe_thread(void *priv_data)
1731 {
1732  ec_master_t *master = (ec_master_t *) priv_data;
1733  ec_eoe_t *eoe;
1734  unsigned int none_open, sth_to_send, all_idle;
1735 
1736  EC_MASTER_DBG(master, 1, "EoE thread running.\n");
1737 
1738  while (!kthread_should_stop()) {
1739  none_open = 1;
1740  all_idle = 1;
1741 
1742  list_for_each_entry(eoe, &master->eoe_handlers, list) {
1743  if (ec_eoe_is_open(eoe)) {
1744  none_open = 0;
1745  break;
1746  }
1747  }
1748  if (none_open)
1749  goto schedule;
1750 
1751  // receive datagrams
1752  master->receive_cb(master->cb_data);
1753 
1754  // actual EoE processing
1755  sth_to_send = 0;
1756  list_for_each_entry(eoe, &master->eoe_handlers, list) {
1757  ec_eoe_run(eoe);
1758  if (eoe->queue_datagram) {
1759  sth_to_send = 1;
1760  }
1761  if (!ec_eoe_is_idle(eoe)) {
1762  all_idle = 0;
1763  }
1764  }
1765 
1766  if (sth_to_send) {
1767  list_for_each_entry(eoe, &master->eoe_handlers, list) {
1768  ec_eoe_queue(eoe);
1769  }
1770  // (try to) send datagrams
1771  down(&master->ext_queue_sem);
1772  master->send_cb(master->cb_data);
1773  up(&master->ext_queue_sem);
1774  }
1775 
1776 schedule:
1777  if (all_idle) {
1778  set_current_state(TASK_INTERRUPTIBLE);
1779  schedule_timeout(1);
1780  } else {
1781  schedule();
1782  }
1783  }
1784 
1785  EC_MASTER_DBG(master, 1, "EoE thread exiting...\n");
1786  return 0;
1787 }
1788 #endif
1789 
1790 /*****************************************************************************/
1791 
1794 void ec_master_attach_slave_configs(
1795  ec_master_t *master
1796  )
1797 {
1798  ec_slave_config_t *sc;
1799 
1800  list_for_each_entry(sc, &master->configs, list) {
1801  ec_slave_config_attach(sc);
1802  }
1803 }
1804 
1805 /*****************************************************************************/
1806 
1810 #define EC_FIND_SLAVE \
1811  do { \
1812  if (alias) { \
1813  for (; slave < master->slaves + master->slave_count; \
1814  slave++) { \
1815  if (slave->effective_alias == alias) \
1816  break; \
1817  } \
1818  if (slave == master->slaves + master->slave_count) \
1819  return NULL; \
1820  } \
1821  \
1822  slave += position; \
1823  if (slave < master->slaves + master->slave_count) { \
1824  return slave; \
1825  } else { \
1826  return NULL; \
1827  } \
1828  } while (0)
1829 
1834 ec_slave_t *ec_master_find_slave(
1835  ec_master_t *master,
1836  uint16_t alias,
1837  uint16_t position
1838  )
1839 {
1840  ec_slave_t *slave = master->slaves;
1841  EC_FIND_SLAVE;
1842 }
1843 
1850 const ec_slave_t *ec_master_find_slave_const(
1851  const ec_master_t *master,
1852  uint16_t alias,
1853  uint16_t position
1854  )
1855 {
1856  const ec_slave_t *slave = master->slaves;
1857  EC_FIND_SLAVE;
1858 }
1859 
1860 /*****************************************************************************/
1861 
1866 unsigned int ec_master_config_count(
1867  const ec_master_t *master
1868  )
1869 {
1870  const ec_slave_config_t *sc;
1871  unsigned int count = 0;
1872 
1873  list_for_each_entry(sc, &master->configs, list) {
1874  count++;
1875  }
1876 
1877  return count;
1878 }
1879 
1880 /*****************************************************************************/
1881 
1885 #define EC_FIND_CONFIG \
1886  do { \
1887  list_for_each_entry(sc, &master->configs, list) { \
1888  if (pos--) \
1889  continue; \
1890  return sc; \
1891  } \
1892  return NULL; \
1893  } while (0)
1894 
1899 ec_slave_config_t *ec_master_get_config(
1900  const ec_master_t *master,
1901  unsigned int pos
1902  )
1903 {
1904  ec_slave_config_t *sc;
1905  EC_FIND_CONFIG;
1906 }
1907 
1914 const ec_slave_config_t *ec_master_get_config_const(
1915  const ec_master_t *master,
1916  unsigned int pos
1917  )
1918 {
1919  const ec_slave_config_t *sc;
1920  EC_FIND_CONFIG;
1921 }
1922 
1923 /*****************************************************************************/
1924 
1929 unsigned int ec_master_domain_count(
1930  const ec_master_t *master
1931  )
1932 {
1933  const ec_domain_t *domain;
1934  unsigned int count = 0;
1935 
1936  list_for_each_entry(domain, &master->domains, list) {
1937  count++;
1938  }
1939 
1940  return count;
1941 }
1942 
1943 /*****************************************************************************/
1944 
1948 #define EC_FIND_DOMAIN \
1949  do { \
1950  list_for_each_entry(domain, &master->domains, list) { \
1951  if (index--) \
1952  continue; \
1953  return domain; \
1954  } \
1955  \
1956  return NULL; \
1957  } while (0)
1958 
1963 ec_domain_t *ec_master_find_domain(
1964  ec_master_t *master,
1965  unsigned int index
1966  )
1967 {
1968  ec_domain_t *domain;
1969  EC_FIND_DOMAIN;
1970 }
1971 
1978 const ec_domain_t *ec_master_find_domain_const(
1979  const ec_master_t *master,
1980  unsigned int index
1981  )
1982 {
1983  const ec_domain_t *domain;
1984  EC_FIND_DOMAIN;
1985 }
1986 
1987 /*****************************************************************************/
1988 
1989 #ifdef EC_EOE
1990 
1995 uint16_t ec_master_eoe_handler_count(
1996  const ec_master_t *master
1997  )
1998 {
1999  const ec_eoe_t *eoe;
2000  unsigned int count = 0;
2001 
2002  list_for_each_entry(eoe, &master->eoe_handlers, list) {
2003  count++;
2004  }
2005 
2006  return count;
2007 }
2008 
2009 /*****************************************************************************/
2010 
2017 const ec_eoe_t *ec_master_get_eoe_handler_const(
2018  const ec_master_t *master,
2019  uint16_t index
2020  )
2021 {
2022  const ec_eoe_t *eoe;
2023 
2024  list_for_each_entry(eoe, &master->eoe_handlers, list) {
2025  if (index--)
2026  continue;
2027  return eoe;
2028  }
2029 
2030  return NULL;
2031 }
2032 
2033 #endif
2034 
2035 /*****************************************************************************/
2036 
2042 int ec_master_debug_level(
2043  ec_master_t *master,
2044  unsigned int level
2045  )
2046 {
2047  if (level > 2) {
2048  EC_MASTER_ERR(master, "Invalid debug level %u!\n", level);
2049  return -EINVAL;
2050  }
2051 
2052  if (level != master->debug_level) {
2053  master->debug_level = level;
2054  EC_MASTER_INFO(master, "Master debug level set to %u.\n",
2055  master->debug_level);
2056  }
2057 
2058  return 0;
2059 }
2060 
2061 /*****************************************************************************/
2062 
2065 void ec_master_find_dc_ref_clock(
2066  ec_master_t *master
2067  )
2068 {
2069  ec_slave_t *slave, *ref = NULL;
2070 
2071  if (master->dc_ref_config) {
2072  // Use application-selected reference clock
2073  slave = master->dc_ref_config->slave;
2074 
2075  if (slave) {
2076  if (slave->base_dc_supported && slave->has_dc_system_time) {
2077  ref = slave;
2078  }
2079  else {
2080  EC_MASTER_WARN(master, "Slave %u can not act as a"
2081  " DC reference clock!", slave->ring_position);
2082  }
2083  }
2084  else {
2085  EC_MASTER_WARN(master, "DC reference clock config (%u-%u)"
2086  " has no slave attached!\n", master->dc_ref_config->alias,
2087  master->dc_ref_config->position);
2088  }
2089  }
2090  else {
2091  // Use first slave with DC support as reference clock
2092  for (slave = master->slaves;
2093  slave < master->slaves + master->slave_count;
2094  slave++) {
2095  if (slave->base_dc_supported && slave->has_dc_system_time) {
2096  ref = slave;
2097  break;
2098  }
2099  }
2100 
2101  }
2102 
2103  master->dc_ref_clock = ref;
2104 
2105  if (ref) {
2106  EC_MASTER_INFO(master, "Using slave %u as DC reference clock.\n",
2107  ref->ring_position);
2108  }
2109  else {
2110  EC_MASTER_INFO(master, "No DC reference clock found.\n");
2111  }
2112 
2113  // These calls always succeed, because the
2114  // datagrams have been pre-allocated.
2115  ec_datagram_fpwr(&master->ref_sync_datagram,
2116  ref ? ref->station_address : 0xffff, 0x0910, 4);
2117  ec_datagram_frmw(&master->sync_datagram,
2118  ref ? ref->station_address : 0xffff, 0x0910, 4);
2119 }
2120 
2121 /*****************************************************************************/
2122 
2127 int ec_master_calc_topology_rec(
2128  ec_master_t *master,
2129  ec_slave_t *port0_slave,
2130  unsigned int *slave_position
2131  )
2132 {
2133  ec_slave_t *slave = master->slaves + *slave_position;
2134  unsigned int port_index;
2135  int ret;
2136 
2137  static const unsigned int next_table[EC_MAX_PORTS] = {
2138  3, 2, 0, 1
2139  };
2140 
2141  slave->ports[0].next_slave = port0_slave;
2142 
2143  port_index = 3;
2144  while (port_index != 0) {
2145  if (!slave->ports[port_index].link.loop_closed) {
2146  *slave_position = *slave_position + 1;
2147  if (*slave_position < master->slave_count) {
2148  slave->ports[port_index].next_slave =
2149  master->slaves + *slave_position;
2150  ret = ec_master_calc_topology_rec(master,
2151  slave, slave_position);
2152  if (ret) {
2153  return ret;
2154  }
2155  } else {
2156  return -1;
2157  }
2158  }
2159 
2160  port_index = next_table[port_index];
2161  }
2162 
2163  return 0;
2164 }
2165 
2166 /*****************************************************************************/
2167 
2170 void ec_master_calc_topology(
2171  ec_master_t *master
2172  )
2173 {
2174  unsigned int slave_position = 0;
2175 
2176  if (master->slave_count == 0)
2177  return;
2178 
2179  if (ec_master_calc_topology_rec(master, NULL, &slave_position))
2180  EC_MASTER_ERR(master, "Failed to calculate bus topology.\n");
2181 }
2182 
2183 /*****************************************************************************/
2184 
2187 void ec_master_calc_transmission_delays(
2188  ec_master_t *master
2189  )
2190 {
2191  ec_slave_t *slave;
2192 
2193  for (slave = master->slaves;
2194  slave < master->slaves + master->slave_count;
2195  slave++) {
2196  ec_slave_calc_port_delays(slave);
2197  }
2198 
2199  if (master->dc_ref_clock) {
2200  uint32_t delay = 0;
2201  ec_slave_calc_transmission_delays_rec(master->dc_ref_clock, &delay);
2202  }
2203 }
2204 
2205 /*****************************************************************************/
2206 
2209 void ec_master_calc_dc(
2210  ec_master_t *master
2211  )
2212 {
2213  // find DC reference clock
2214  ec_master_find_dc_ref_clock(master);
2215 
2216  // calculate bus topology
2217  ec_master_calc_topology(master);
2218 
2219  ec_master_calc_transmission_delays(master);
2220 }
2221 
2222 /*****************************************************************************/
2223 
2226 void ec_master_request_op(
2227  ec_master_t *master
2228  )
2229 {
2230  unsigned int i;
2231  ec_slave_t *slave;
2232 
2233  if (!master->active)
2234  return;
2235 
2236  EC_MASTER_DBG(master, 1, "Requesting OP...\n");
2237 
2238  // request OP for all configured slaves
2239  for (i = 0; i < master->slave_count; i++) {
2240  slave = master->slaves + i;
2241  if (slave->config) {
2242  ec_slave_request_state(slave, EC_SLAVE_STATE_OP);
2243  }
2244  }
2245 
2246  // always set DC reference clock to OP
2247  if (master->dc_ref_clock) {
2248  ec_slave_request_state(master->dc_ref_clock, EC_SLAVE_STATE_OP);
2249  }
2250 }
2251 
2252 /******************************************************************************
2253  * Application interface
2254  *****************************************************************************/
2255 
2260 ec_domain_t *ecrt_master_create_domain_err(
2261  ec_master_t *master
2262  )
2263 {
2264  ec_domain_t *domain, *last_domain;
2265  unsigned int index;
2266 
2267  EC_MASTER_DBG(master, 1, "ecrt_master_create_domain(master = 0x%p)\n",
2268  master);
2269 
2270  if (!(domain =
2271  (ec_domain_t *) kmalloc(sizeof(ec_domain_t), GFP_KERNEL))) {
2272  EC_MASTER_ERR(master, "Error allocating domain memory!\n");
2273  return ERR_PTR(-ENOMEM);
2274  }
2275 
2276  down(&master->master_sem);
2277 
2278  if (list_empty(&master->domains)) {
2279  index = 0;
2280  } else {
2281  last_domain = list_entry(master->domains.prev, ec_domain_t, list);
2282  index = last_domain->index + 1;
2283  }
2284 
2285  ec_domain_init(domain, master, index);
2286  list_add_tail(&domain->list, &master->domains);
2287 
2288  up(&master->master_sem);
2289 
2290  EC_MASTER_DBG(master, 1, "Created domain %u.\n", domain->index);
2291 
2292  return domain;
2293 }
2294 
2295 /*****************************************************************************/
2296 
2297 ec_domain_t *ecrt_master_create_domain(
2298  ec_master_t *master
2299  )
2300 {
2301  ec_domain_t *d = ecrt_master_create_domain_err(master);
2302  return IS_ERR(d) ? NULL : d;
2303 }
2304 
2305 /*****************************************************************************/
2306 
2307 int ecrt_master_activate(ec_master_t *master)
2308 {
2309  uint32_t domain_offset;
2310  ec_domain_t *domain;
2311  int ret;
2312 #ifdef EC_EOE
2313  int eoe_was_running;
2314 #endif
2315 
2316  EC_MASTER_DBG(master, 1, "ecrt_master_activate(master = 0x%p)\n", master);
2317 
2318  if (master->active) {
2319  EC_MASTER_WARN(master, "%s: Master already active!\n", __func__);
2320  return 0;
2321  }
2322 
2323  down(&master->master_sem);
2324 
2325  // finish all domains
2326  domain_offset = 0;
2327  list_for_each_entry(domain, &master->domains, list) {
2328  ret = ec_domain_finish(domain, domain_offset);
2329  if (ret < 0) {
2330  up(&master->master_sem);
2331  EC_MASTER_ERR(master, "Failed to finish domain 0x%p!\n", domain);
2332  return ret;
2333  }
2334  domain_offset += domain->data_size;
2335  }
2336 
2337  up(&master->master_sem);
2338 
2339  // restart EoE process and master thread with new locking
2340 
2341  ec_master_thread_stop(master);
2342 #ifdef EC_EOE
2343  eoe_was_running = master->eoe_thread != NULL;
2344  ec_master_eoe_stop(master);
2345 #endif
2346 
2347  EC_MASTER_DBG(master, 1, "FSM datagram is %p.\n", &master->fsm_datagram);
2348 
2349  master->injection_seq_fsm = 0;
2350  master->injection_seq_rt = 0;
2351 
2352  master->send_cb = master->app_send_cb;
2353  master->receive_cb = master->app_receive_cb;
2354  master->cb_data = master->app_cb_data;
2355 
2356 #ifdef EC_EOE
2357  if (eoe_was_running) {
2358  ec_master_eoe_start(master);
2359  }
2360 #endif
2361  ret = ec_master_thread_start(master, ec_master_operation_thread,
2362  "EtherCAT-OP");
2363  if (ret < 0) {
2364  EC_MASTER_ERR(master, "Failed to start master thread!\n");
2365  return ret;
2366  }
2367 
2368  /* Allow scanning after a topology change. */
2369  master->allow_scan = 1;
2370 
2371  master->active = 1;
2372 
2373  // notify state machine, that the configuration shall now be applied
2374  master->config_changed = 1;
2375 
2376  return 0;
2377 }
2378 
2379 /*****************************************************************************/
2380 
2381 void ecrt_master_deactivate(ec_master_t *master)
2382 {
2383  ec_slave_t *slave;
2384 #ifdef EC_EOE
2385  ec_eoe_t *eoe;
2386  int eoe_was_running;
2387 #endif
2388 
2389  EC_MASTER_DBG(master, 1, "%s(master = 0x%p)\n", __func__, master);
2390 
2391  if (!master->active) {
2392  EC_MASTER_WARN(master, "%s: Master not active.\n", __func__);
2393  return;
2394  }
2395 
2396  ec_master_thread_stop(master);
2397 #ifdef EC_EOE
2398  eoe_was_running = master->eoe_thread != NULL;
2399  ec_master_eoe_stop(master);
2400 #endif
2401 
2402  master->send_cb = ec_master_internal_send_cb;
2403  master->receive_cb = ec_master_internal_receive_cb;
2404  master->cb_data = master;
2405 
2406  ec_master_clear_config(master);
2407 
2408  for (slave = master->slaves;
2409  slave < master->slaves + master->slave_count;
2410  slave++) {
2411 
2412  // set states for all slaves
2413  ec_slave_request_state(slave, EC_SLAVE_STATE_PREOP);
2414 
2415  // mark for reconfiguration, because the master could have no
2416  // possibility for a reconfiguration between two sequential operation
2417  // phases.
2418  slave->force_config = 1;
2419  }
2420 
2421 #ifdef EC_EOE
2422  // ... but leave EoE slaves in OP
2423  list_for_each_entry(eoe, &master->eoe_handlers, list) {
2424  if (ec_eoe_is_open(eoe))
2425  ec_slave_request_state(eoe->slave, EC_SLAVE_STATE_OP);
2426  }
2427 #endif
2428 
2429  master->app_time = 0ULL;
2430  master->dc_ref_time = 0ULL;
2431 
2432 #ifdef EC_EOE
2433  if (eoe_was_running) {
2434  ec_master_eoe_start(master);
2435  }
2436 #endif
2437  if (ec_master_thread_start(master, ec_master_idle_thread,
2438  "EtherCAT-IDLE")) {
2439  EC_MASTER_WARN(master, "Failed to restart master thread!\n");
2440  }
2441 
2442  /* Disallow scanning to get into the same state like after a master
2443  * request (after ec_master_enter_operation_phase() is called). */
2444  master->allow_scan = 0;
2445 
2446  master->active = 0;
2447 }
2448 
2449 /*****************************************************************************/
2450 
2451 void ecrt_master_send(ec_master_t *master)
2452 {
2453  ec_datagram_t *datagram, *n;
2454  ec_device_index_t dev_idx;
2455 
2456  if (master->injection_seq_rt != master->injection_seq_fsm) {
2457  // inject datagram produced by master FSM
2458  ec_master_queue_datagram(master, &master->fsm_datagram);
2459  master->injection_seq_rt = master->injection_seq_fsm;
2460  }
2461 
2462  ec_master_inject_external_datagrams(master);
2463 
2464  for (dev_idx = EC_DEVICE_MAIN; dev_idx < ec_master_num_devices(master);
2465  dev_idx++) {
2466  if (unlikely(!master->devices[dev_idx].link_state)) {
2467  // link is down, no datagram can be sent
2468  list_for_each_entry_safe(datagram, n,
2469  &master->datagram_queue, queue) {
2470  if (datagram->device_index == dev_idx) {
2471  datagram->state = EC_DATAGRAM_ERROR;
2472  list_del_init(&datagram->queue);
2473  }
2474  }
2475 
2476  if (!master->devices[dev_idx].dev) {
2477  continue;
2478  }
2479 
2480  // query link state
2481  ec_device_poll(&master->devices[dev_idx]);
2482 
2483  // clear frame statistics
2484  ec_device_clear_stats(&master->devices[dev_idx]);
2485  continue;
2486  }
2487 
2488  // send frames
2489  ec_master_send_datagrams(master, dev_idx);
2490  }
2491 }
2492 
2493 /*****************************************************************************/
2494 
2495 void ecrt_master_receive(ec_master_t *master)
2496 {
2497  unsigned int dev_idx;
2498  ec_datagram_t *datagram, *next;
2499 
2500  // receive datagrams
2501  for (dev_idx = EC_DEVICE_MAIN; dev_idx < ec_master_num_devices(master);
2502  dev_idx++) {
2503  ec_device_poll(&master->devices[dev_idx]);
2504  }
2505  ec_master_update_device_stats(master);
2506 
2507  // dequeue all datagrams that timed out
2508  list_for_each_entry_safe(datagram, next, &master->datagram_queue, queue) {
2509  if (datagram->state != EC_DATAGRAM_SENT) continue;
2510 
2511 #ifdef EC_HAVE_CYCLES
2512  if (master->devices[EC_DEVICE_MAIN].cycles_poll -
2513  datagram->cycles_sent > timeout_cycles) {
2514 #else
2515  if (master->devices[EC_DEVICE_MAIN].jiffies_poll -
2516  datagram->jiffies_sent > timeout_jiffies) {
2517 #endif
2518  list_del_init(&datagram->queue);
2519  datagram->state = EC_DATAGRAM_TIMED_OUT;
2520  master->stats.timeouts++;
2521 
2522 #ifdef EC_RT_SYSLOG
2523  ec_master_output_stats(master);
2524 
2525  if (unlikely(master->debug_level > 0)) {
2526  unsigned int time_us;
2527 #ifdef EC_HAVE_CYCLES
2528  time_us = (unsigned int)
2529  (master->devices[EC_DEVICE_MAIN].cycles_poll -
2530  datagram->cycles_sent) * 1000 / cpu_khz;
2531 #else
2532  time_us = (unsigned int)
2533  ((master->devices[EC_DEVICE_MAIN].jiffies_poll -
2534  datagram->jiffies_sent) * 1000000 / HZ);
2535 #endif
2536  EC_MASTER_DBG(master, 0, "TIMED OUT datagram %p,"
2537  " index %02X waited %u us.\n",
2538  datagram, datagram->index, time_us);
2539  }
2540 #endif /* RT_SYSLOG */
2541  }
2542  }
2543 }
2544 
2545 /*****************************************************************************/
2546 
2547 void ecrt_master_send_ext(ec_master_t *master)
2548 {
2549  ec_datagram_t *datagram, *next;
2550 
2551  list_for_each_entry_safe(datagram, next, &master->ext_datagram_queue,
2552  queue) {
2553  list_del(&datagram->queue);
2554  ec_master_queue_datagram(master, datagram);
2555  }
2556 
2557  ecrt_master_send(master);
2558 }
2559 
2560 /*****************************************************************************/
2561 
2564 ec_slave_config_t *ecrt_master_slave_config_err(ec_master_t *master,
2565  uint16_t alias, uint16_t position, uint32_t vendor_id,
2566  uint32_t product_code)
2567 {
2568  ec_slave_config_t *sc;
2569  unsigned int found = 0;
2570 
2571 
2572  EC_MASTER_DBG(master, 1, "ecrt_master_slave_config(master = 0x%p,"
2573  " alias = %u, position = %u, vendor_id = 0x%08x,"
2574  " product_code = 0x%08x)\n",
2575  master, alias, position, vendor_id, product_code);
2576 
2577  list_for_each_entry(sc, &master->configs, list) {
2578  if (sc->alias == alias && sc->position == position) {
2579  found = 1;
2580  break;
2581  }
2582  }
2583 
2584  if (found) { // config with same alias/position already existing
2585  if (sc->vendor_id != vendor_id || sc->product_code != product_code) {
2586  EC_MASTER_ERR(master, "Slave type mismatch. Slave was"
2587  " configured as 0x%08X/0x%08X before. Now configuring"
2588  " with 0x%08X/0x%08X.\n", sc->vendor_id, sc->product_code,
2589  vendor_id, product_code);
2590  return ERR_PTR(-ENOENT);
2591  }
2592  } else {
2593  EC_MASTER_DBG(master, 1, "Creating slave configuration for %u:%u,"
2594  " 0x%08X/0x%08X.\n",
2595  alias, position, vendor_id, product_code);
2596 
2597  if (!(sc = (ec_slave_config_t *) kmalloc(sizeof(ec_slave_config_t),
2598  GFP_KERNEL))) {
2599  EC_MASTER_ERR(master, "Failed to allocate memory"
2600  " for slave configuration.\n");
2601  return ERR_PTR(-ENOMEM);
2602  }
2603 
2604  ec_slave_config_init(sc, master,
2605  alias, position, vendor_id, product_code);
2606 
2607  down(&master->master_sem);
2608 
2609  // try to find the addressed slave
2610  ec_slave_config_attach(sc);
2611  ec_slave_config_load_default_sync_config(sc);
2612  list_add_tail(&sc->list, &master->configs);
2613 
2614  up(&master->master_sem);
2615  }
2616 
2617  return sc;
2618 }
2619 
2620 /*****************************************************************************/
2621 
2622 ec_slave_config_t *ecrt_master_slave_config(ec_master_t *master,
2623  uint16_t alias, uint16_t position, uint32_t vendor_id,
2624  uint32_t product_code)
2625 {
2626  ec_slave_config_t *sc = ecrt_master_slave_config_err(master, alias,
2627  position, vendor_id, product_code);
2628  return IS_ERR(sc) ? NULL : sc;
2629 }
2630 
2631 /*****************************************************************************/
2632 
2633 int ecrt_master_select_reference_clock(ec_master_t *master,
2634  ec_slave_config_t *sc)
2635 {
2636  if (sc) {
2637  ec_slave_t *slave = sc->slave;
2638 
2639  // output an early warning
2640  if (slave &&
2641  (!slave->base_dc_supported || !slave->has_dc_system_time)) {
2642  EC_MASTER_WARN(master, "Slave %u can not act as"
2643  " a reference clock!", slave->ring_position);
2644  }
2645  }
2646 
2647  master->dc_ref_config = sc;
2648  return 0;
2649 }
2650 
2651 /*****************************************************************************/
2652 
2653 int ecrt_master(ec_master_t *master, ec_master_info_t *master_info)
2654 {
2655  EC_MASTER_DBG(master, 1, "ecrt_master(master = 0x%p,"
2656  " master_info = 0x%p)\n", master, master_info);
2657 
2658  master_info->slave_count = master->slave_count;
2659  master_info->link_up = master->devices[EC_DEVICE_MAIN].link_state;
2660  master_info->scan_busy = master->scan_busy;
2661  master_info->app_time = master->app_time;
2662  return 0;
2663 }
2664 
2665 /*****************************************************************************/
2666 
2667 int ecrt_master_get_slave(ec_master_t *master, uint16_t slave_position,
2668  ec_slave_info_t *slave_info)
2669 {
2670  const ec_slave_t *slave;
2671  unsigned int i;
2672  int ret = 0;
2673 
2674  if (down_interruptible(&master->master_sem)) {
2675  return -EINTR;
2676  }
2677 
2678  slave = ec_master_find_slave_const(master, 0, slave_position);
2679 
2680  if (slave == NULL) {
2681  ret = -ENOENT;
2682  goto out_get_slave;
2683  }
2684 
2685  slave_info->position = slave->ring_position;
2686  slave_info->vendor_id = slave->sii.vendor_id;
2687  slave_info->product_code = slave->sii.product_code;
2688  slave_info->revision_number = slave->sii.revision_number;
2689  slave_info->serial_number = slave->sii.serial_number;
2690  slave_info->alias = slave->effective_alias;
2691  slave_info->current_on_ebus = slave->sii.current_on_ebus;
2692 
2693  for (i = 0; i < EC_MAX_PORTS; i++) {
2694  slave_info->ports[i].desc = slave->ports[i].desc;
2695  slave_info->ports[i].link.link_up = slave->ports[i].link.link_up;
2696  slave_info->ports[i].link.loop_closed =
2697  slave->ports[i].link.loop_closed;
2698  slave_info->ports[i].link.signal_detected =
2699  slave->ports[i].link.signal_detected;
2700  slave_info->ports[i].receive_time = slave->ports[i].receive_time;
2701  if (slave->ports[i].next_slave) {
2702  slave_info->ports[i].next_slave =
2703  slave->ports[i].next_slave->ring_position;
2704  } else {
2705  slave_info->ports[i].next_slave = 0xffff;
2706  }
2707  slave_info->ports[i].delay_to_next_dc =
2708  slave->ports[i].delay_to_next_dc;
2709  }
2710 
2711  slave_info->al_state = slave->current_state;
2712  slave_info->error_flag = slave->error_flag;
2713  slave_info->sync_count = slave->sii.sync_count;
2714  slave_info->sdo_count = ec_slave_sdo_count(slave);
2715  if (slave->sii.name) {
2716  strncpy(slave_info->name, slave->sii.name, EC_MAX_STRING_LENGTH);
2717  } else {
2718  slave_info->name[0] = 0;
2719  }
2720 
2721 out_get_slave:
2722  up(&master->master_sem);
2723 
2724  return ret;
2725 }
2726 
2727 /*****************************************************************************/
2728 
2729 void ecrt_master_callbacks(ec_master_t *master,
2730  void (*send_cb)(void *), void (*receive_cb)(void *), void *cb_data)
2731 {
2732  EC_MASTER_DBG(master, 1, "ecrt_master_callbacks(master = 0x%p,"
2733  " send_cb = 0x%p, receive_cb = 0x%p, cb_data = 0x%p)\n",
2734  master, send_cb, receive_cb, cb_data);
2735 
2736  master->app_send_cb = send_cb;
2737  master->app_receive_cb = receive_cb;
2738  master->app_cb_data = cb_data;
2739 }
2740 
2741 /*****************************************************************************/
2742 
2743 void ecrt_master_state(const ec_master_t *master, ec_master_state_t *state)
2744 {
2745  ec_device_index_t dev_idx;
2746 
2747  state->slaves_responding = 0U;
2748  state->al_states = 0;
2749  state->link_up = 0U;
2750 
2751  for (dev_idx = EC_DEVICE_MAIN; dev_idx < ec_master_num_devices(master);
2752  dev_idx++) {
2753  /* Announce sum of responding slaves on all links. */
2754  state->slaves_responding += master->fsm.slaves_responding[dev_idx];
2755 
2756  /* Binary-or slave states of all links. */
2757  state->al_states |= master->fsm.slave_states[dev_idx];
2758 
2759  /* Signal link up if at least one device has link. */
2760  state->link_up |= master->devices[dev_idx].link_state;
2761  }
2762 }
2763 
2764 /*****************************************************************************/
2765 
2766 int ecrt_master_link_state(const ec_master_t *master, unsigned int dev_idx,
2767  ec_master_link_state_t *state)
2768 {
2769  if (dev_idx >= ec_master_num_devices(master)) {
2770  return -EINVAL;
2771  }
2772 
2773  state->slaves_responding = master->fsm.slaves_responding[dev_idx];
2774  state->al_states = master->fsm.slave_states[dev_idx];
2775  state->link_up = master->devices[dev_idx].link_state;
2776 
2777  return 0;
2778 }
2779 
2780 /*****************************************************************************/
2781 
2782 void ecrt_master_application_time(ec_master_t *master, uint64_t app_time)
2783 {
2784  master->app_time = app_time;
2785 
2786  if (unlikely(!master->dc_ref_time)) {
2787  master->dc_ref_time = app_time;
2788  }
2789 }
2790 
2791 /*****************************************************************************/
2792 
2793 int ecrt_master_reference_clock_time(ec_master_t *master, uint32_t *time)
2794 {
2795  if (!master->dc_ref_clock) {
2796  return -ENXIO;
2797  }
2798 
2799  if (master->sync_datagram.state != EC_DATAGRAM_RECEIVED) {
2800  return -EIO;
2801  }
2802 
2803  // Get returned datagram time, transmission delay removed.
2804  *time = EC_READ_U32(master->sync_datagram.data) -
2805  master->dc_ref_clock->transmission_delay;
2806 
2807  return 0;
2808 }
2809 
2810 /*****************************************************************************/
2811 
2812 void ecrt_master_sync_reference_clock(ec_master_t *master)
2813 {
2814  if (master->dc_ref_clock) {
2815  EC_WRITE_U32(master->ref_sync_datagram.data, master->app_time);
2816  ec_master_queue_datagram(master, &master->ref_sync_datagram);
2817  }
2818 }
2819 
2820 /*****************************************************************************/
2821 
2822 void ecrt_master_sync_reference_clock_to(
2823  ec_master_t *master,
2824  uint64_t sync_time
2825  )
2826 {
2827  if (master->dc_ref_clock) {
2828  EC_WRITE_U32(master->ref_sync_datagram.data, sync_time);
2829  ec_master_queue_datagram(master, &master->ref_sync_datagram);
2830  }
2831 }
2832 
2833 /*****************************************************************************/
2834 
2835 void ecrt_master_sync_slave_clocks(ec_master_t *master)
2836 {
2837  if (master->dc_ref_clock) {
2838  ec_datagram_zero(&master->sync_datagram);
2839  ec_master_queue_datagram(master, &master->sync_datagram);
2840  }
2841 }
2842 
2843 /*****************************************************************************/
2844 
2845 void ecrt_master_sync_monitor_queue(ec_master_t *master)
2846 {
2847  ec_datagram_zero(&master->sync_mon_datagram);
2848  ec_master_queue_datagram(master, &master->sync_mon_datagram);
2849 }
2850 
2851 /*****************************************************************************/
2852 
2853 uint32_t ecrt_master_sync_monitor_process(ec_master_t *master)
2854 {
2855  if (master->sync_mon_datagram.state == EC_DATAGRAM_RECEIVED) {
2856  return EC_READ_U32(master->sync_mon_datagram.data) & 0x7fffffff;
2857  } else {
2858  return 0xffffffff;
2859  }
2860 }
2861 
2862 /*****************************************************************************/
2863 
2864 int ecrt_master_sdo_download(ec_master_t *master, uint16_t slave_position,
2865  uint16_t index, uint8_t subindex, uint8_t *data,
2866  size_t data_size, uint32_t *abort_code)
2867 {
2868  ec_sdo_request_t request;
2869  ec_slave_t *slave;
2870  int ret;
2871 
2872  EC_MASTER_DBG(master, 1, "%s(master = 0x%p,"
2873  " slave_position = %u, index = 0x%04X, subindex = 0x%02X,"
2874  " data = 0x%p, data_size = %zu, abort_code = 0x%p)\n",
2875  __func__, master, slave_position, index, subindex,
2876  data, data_size, abort_code);
2877 
2878  if (!data_size) {
2879  EC_MASTER_ERR(master, "Zero data size!\n");
2880  return -EINVAL;
2881  }
2882 
2883  ec_sdo_request_init(&request);
2884  ecrt_sdo_request_index(&request, index, subindex);
2885  ret = ec_sdo_request_alloc(&request, data_size);
2886  if (ret) {
2887  ec_sdo_request_clear(&request);
2888  return ret;
2889  }
2890 
2891  memcpy(request.data, data, data_size);
2892  request.data_size = data_size;
2893  ecrt_sdo_request_write(&request);
2894 
2895  if (down_interruptible(&master->master_sem)) {
2896  ec_sdo_request_clear(&request);
2897  return -EINTR;
2898  }
2899 
2900  if (!(slave = ec_master_find_slave(master, 0, slave_position))) {
2901  up(&master->master_sem);
2902  EC_MASTER_ERR(master, "Slave %u does not exist!\n", slave_position);
2903  ec_sdo_request_clear(&request);
2904  return -EINVAL;
2905  }
2906 
2907  EC_SLAVE_DBG(slave, 1, "Scheduling SDO download request.\n");
2908 
2909  // schedule request.
2910  list_add_tail(&request.list, &slave->sdo_requests);
2911 
2912  up(&master->master_sem);
2913 
2914  // wait for processing through FSM
2915  if (wait_event_interruptible(master->request_queue,
2916  request.state != EC_INT_REQUEST_QUEUED)) {
2917  // interrupted by signal
2918  down(&master->master_sem);
2919  if (request.state == EC_INT_REQUEST_QUEUED) {
2920  list_del(&request.list);
2921  up(&master->master_sem);
2922  ec_sdo_request_clear(&request);
2923  return -EINTR;
2924  }
2925  // request already processing: interrupt not possible.
2926  up(&master->master_sem);
2927  }
2928 
2929  // wait until master FSM has finished processing
2930  wait_event(master->request_queue, request.state != EC_INT_REQUEST_BUSY);
2931 
2932  *abort_code = request.abort_code;
2933 
2934  if (request.state == EC_INT_REQUEST_SUCCESS) {
2935  ret = 0;
2936  } else if (request.errno) {
2937  ret = -request.errno;
2938  } else {
2939  ret = -EIO;
2940  }
2941 
2942  ec_sdo_request_clear(&request);
2943  return ret;
2944 }
2945 
2946 /*****************************************************************************/
2947 
2948 int ecrt_master_sdo_download_complete(ec_master_t *master,
2949  uint16_t slave_position, uint16_t index, uint8_t *data,
2950  size_t data_size, uint32_t *abort_code)
2951 {
2952  ec_sdo_request_t request;
2953  ec_slave_t *slave;
2954  int ret;
2955 
2956  EC_MASTER_DBG(master, 1, "%s(master = 0x%p,"
2957  " slave_position = %u, index = 0x%04X,"
2958  " data = 0x%p, data_size = %zu, abort_code = 0x%p)\n",
2959  __func__, master, slave_position, index, data, data_size,
2960  abort_code);
2961 
2962  if (!data_size) {
2963  EC_MASTER_ERR(master, "Zero data size!\n");
2964  return -EINVAL;
2965  }
2966 
2967  ec_sdo_request_init(&request);
2968  ecrt_sdo_request_index(&request, index, 0);
2969  ret = ec_sdo_request_alloc(&request, data_size);
2970  if (ret) {
2971  ec_sdo_request_clear(&request);
2972  return ret;
2973  }
2974 
2975  request.complete_access = 1;
2976  memcpy(request.data, data, data_size);
2977  request.data_size = data_size;
2978  ecrt_sdo_request_write(&request);
2979 
2980  if (down_interruptible(&master->master_sem)) {
2981  ec_sdo_request_clear(&request);
2982  return -EINTR;
2983  }
2984 
2985  if (!(slave = ec_master_find_slave(master, 0, slave_position))) {
2986  up(&master->master_sem);
2987  EC_MASTER_ERR(master, "Slave %u does not exist!\n", slave_position);
2988  ec_sdo_request_clear(&request);
2989  return -EINVAL;
2990  }
2991 
2992  EC_SLAVE_DBG(slave, 1, "Scheduling SDO download request"
2993  " (complete access).\n");
2994 
2995  // schedule request.
2996  list_add_tail(&request.list, &slave->sdo_requests);
2997 
2998  up(&master->master_sem);
2999 
3000  // wait for processing through FSM
3001  if (wait_event_interruptible(master->request_queue,
3002  request.state != EC_INT_REQUEST_QUEUED)) {
3003  // interrupted by signal
3004  down(&master->master_sem);
3005  if (request.state == EC_INT_REQUEST_QUEUED) {
3006  list_del(&request.list);
3007  up(&master->master_sem);
3008  ec_sdo_request_clear(&request);
3009  return -EINTR;
3010  }
3011  // request already processing: interrupt not possible.
3012  up(&master->master_sem);
3013  }
3014 
3015  // wait until master FSM has finished processing
3016  wait_event(master->request_queue, request.state != EC_INT_REQUEST_BUSY);
3017 
3018  *abort_code = request.abort_code;
3019 
3020  if (request.state == EC_INT_REQUEST_SUCCESS) {
3021  ret = 0;
3022  } else if (request.errno) {
3023  ret = -request.errno;
3024  } else {
3025  ret = -EIO;
3026  }
3027 
3028  ec_sdo_request_clear(&request);
3029  return ret;
3030 }
3031 
3032 /*****************************************************************************/
3033 
3034 int ecrt_master_sdo_upload(ec_master_t *master, uint16_t slave_position,
3035  uint16_t index, uint8_t subindex, uint8_t *target,
3036  size_t target_size, size_t *result_size, uint32_t *abort_code)
3037 {
3038  ec_sdo_request_t request;
3039  ec_slave_t *slave;
3040  int ret = 0;
3041 
3042  EC_MASTER_DBG(master, 1, "%s(master = 0x%p,"
3043  " slave_position = %u, index = 0x%04X, subindex = 0x%02X,"
3044  " target = 0x%p, target_size = %zu, result_size = 0x%p,"
3045  " abort_code = 0x%p)\n",
3046  __func__, master, slave_position, index, subindex,
3047  target, target_size, result_size, abort_code);
3048 
3049  ec_sdo_request_init(&request);
3050  ecrt_sdo_request_index(&request, index, subindex);
3051  ecrt_sdo_request_read(&request);
3052 
3053  if (down_interruptible(&master->master_sem)) {
3054  ec_sdo_request_clear(&request);
3055  return -EINTR;
3056  }
3057 
3058  if (!(slave = ec_master_find_slave(master, 0, slave_position))) {
3059  up(&master->master_sem);
3060  ec_sdo_request_clear(&request);
3061  EC_MASTER_ERR(master, "Slave %u does not exist!\n", slave_position);
3062  return -EINVAL;
3063  }
3064 
3065  EC_SLAVE_DBG(slave, 1, "Scheduling SDO upload request.\n");
3066 
3067  // schedule request.
3068  list_add_tail(&request.list, &slave->sdo_requests);
3069 
3070  up(&master->master_sem);
3071 
3072  // wait for processing through FSM
3073  if (wait_event_interruptible(master->request_queue,
3074  request.state != EC_INT_REQUEST_QUEUED)) {
3075  // interrupted by signal
3076  down(&master->master_sem);
3077  if (request.state == EC_INT_REQUEST_QUEUED) {
3078  list_del(&request.list);
3079  up(&master->master_sem);
3080  ec_sdo_request_clear(&request);
3081  return -EINTR;
3082  }
3083  // request already processing: interrupt not possible.
3084  up(&master->master_sem);
3085  }
3086 
3087  // wait until master FSM has finished processing
3088  wait_event(master->request_queue, request.state != EC_INT_REQUEST_BUSY);
3089 
3090  *abort_code = request.abort_code;
3091 
3092  if (request.state != EC_INT_REQUEST_SUCCESS) {
3093  *result_size = 0;
3094  if (request.errno) {
3095  ret = -request.errno;
3096  } else {
3097  ret = -EIO;
3098  }
3099  } else {
3100  if (request.data_size > target_size) {
3101  EC_SLAVE_ERR(slave, "%s(): Buffer too small.\n", __func__);
3102  ret = -EOVERFLOW;
3103  }
3104  else {
3105  memcpy(target, request.data, request.data_size);
3106  *result_size = request.data_size;
3107  ret = 0;
3108  }
3109  }
3110 
3111  ec_sdo_request_clear(&request);
3112  return ret;
3113 }
3114 
3115 /*****************************************************************************/
3116 
3117 int ecrt_master_write_idn(ec_master_t *master, uint16_t slave_position,
3118  uint8_t drive_no, uint16_t idn, uint8_t *data, size_t data_size,
3119  uint16_t *error_code)
3120 {
3121  ec_soe_request_t request;
3122  ec_slave_t *slave;
3123  int ret;
3124 
3125  if (drive_no > 7) {
3126  EC_MASTER_ERR(master, "Invalid drive number!\n");
3127  return -EINVAL;
3128  }
3129 
3130  ec_soe_request_init(&request);
3131  ec_soe_request_set_drive_no(&request, drive_no);
3132  ec_soe_request_set_idn(&request, idn);
3133 
3134  ret = ec_soe_request_alloc(&request, data_size);
3135  if (ret) {
3136  ec_soe_request_clear(&request);
3137  return ret;
3138  }
3139 
3140  memcpy(request.data, data, data_size);
3141  request.data_size = data_size;
3142  ec_soe_request_write(&request);
3143 
3144  if (down_interruptible(&master->master_sem)) {
3145  ec_soe_request_clear(&request);
3146  return -EINTR;
3147  }
3148 
3149  if (!(slave = ec_master_find_slave(master, 0, slave_position))) {
3150  up(&master->master_sem);
3151  EC_MASTER_ERR(master, "Slave %u does not exist!\n",
3152  slave_position);
3153  ec_soe_request_clear(&request);
3154  return -EINVAL;
3155  }
3156 
3157  EC_SLAVE_DBG(slave, 1, "Scheduling SoE write request.\n");
3158 
3159  // schedule SoE write request.
3160  list_add_tail(&request.list, &slave->soe_requests);
3161 
3162  up(&master->master_sem);
3163 
3164  // wait for processing through FSM
3165  if (wait_event_interruptible(master->request_queue,
3166  request.state != EC_INT_REQUEST_QUEUED)) {
3167  // interrupted by signal
3168  down(&master->master_sem);
3169  if (request.state == EC_INT_REQUEST_QUEUED) {
3170  // abort request
3171  list_del(&request.list);
3172  up(&master->master_sem);
3173  ec_soe_request_clear(&request);
3174  return -EINTR;
3175  }
3176  up(&master->master_sem);
3177  }
3178 
3179  // wait until master FSM has finished processing
3180  wait_event(master->request_queue, request.state != EC_INT_REQUEST_BUSY);
3181 
3182  if (error_code) {
3183  *error_code = request.error_code;
3184  }
3185  ret = request.state == EC_INT_REQUEST_SUCCESS ? 0 : -EIO;
3186  ec_soe_request_clear(&request);
3187 
3188  return ret;
3189 }
3190 
3191 /*****************************************************************************/
3192 
3193 int ecrt_master_read_idn(ec_master_t *master, uint16_t slave_position,
3194  uint8_t drive_no, uint16_t idn, uint8_t *target, size_t target_size,
3195  size_t *result_size, uint16_t *error_code)
3196 {
3197  ec_soe_request_t request;
3198  ec_slave_t *slave;
3199  int ret;
3200 
3201  if (drive_no > 7) {
3202  EC_MASTER_ERR(master, "Invalid drive number!\n");
3203  return -EINVAL;
3204  }
3205 
3206  ec_soe_request_init(&request);
3207  ec_soe_request_set_drive_no(&request, drive_no);
3208  ec_soe_request_set_idn(&request, idn);
3209  ec_soe_request_read(&request);
3210 
3211  if (down_interruptible(&master->master_sem)) {
3212  ec_soe_request_clear(&request);
3213  return -EINTR;
3214  }
3215 
3216  if (!(slave = ec_master_find_slave(master, 0, slave_position))) {
3217  up(&master->master_sem);
3218  ec_soe_request_clear(&request);
3219  EC_MASTER_ERR(master, "Slave %u does not exist!\n", slave_position);
3220  return -EINVAL;
3221  }
3222 
3223  EC_SLAVE_DBG(slave, 1, "Scheduling SoE read request.\n");
3224 
3225  // schedule request.
3226  list_add_tail(&request.list, &slave->soe_requests);
3227 
3228  up(&master->master_sem);
3229 
3230  // wait for processing through FSM
3231  if (wait_event_interruptible(master->request_queue,
3232  request.state != EC_INT_REQUEST_QUEUED)) {
3233  // interrupted by signal
3234  down(&master->master_sem);
3235  if (request.state == EC_INT_REQUEST_QUEUED) {
3236  list_del(&request.list);
3237  up(&master->master_sem);
3238  ec_soe_request_clear(&request);
3239  return -EINTR;
3240  }
3241  // request already processing: interrupt not possible.
3242  up(&master->master_sem);
3243  }
3244 
3245  // wait until master FSM has finished processing
3246  wait_event(master->request_queue, request.state != EC_INT_REQUEST_BUSY);
3247 
3248  if (error_code) {
3249  *error_code = request.error_code;
3250  }
3251 
3252  if (request.state != EC_INT_REQUEST_SUCCESS) {
3253  if (result_size) {
3254  *result_size = 0;
3255  }
3256  ret = -EIO;
3257  } else { // success
3258  if (request.data_size > target_size) {
3259  EC_SLAVE_ERR(slave, "%s(): Buffer too small.\n", __func__);
3260  ret = -EOVERFLOW;
3261  }
3262  else { // data fits in buffer
3263  if (result_size) {
3264  *result_size = request.data_size;
3265  }
3266  memcpy(target, request.data, request.data_size);
3267  ret = 0;
3268  }
3269  }
3270 
3271  ec_soe_request_clear(&request);
3272  return ret;
3273 }
3274 
3275 /*****************************************************************************/
3276 
3277 void ecrt_master_reset(ec_master_t *master)
3278 {
3279  ec_slave_config_t *sc;
3280 
3281  list_for_each_entry(sc, &master->configs, list) {
3282  if (sc->slave) {
3283  ec_slave_request_state(sc->slave, EC_SLAVE_STATE_OP);
3284  }
3285  }
3286 }
3287 
3288 /*****************************************************************************/
3289 
3292 EXPORT_SYMBOL(ecrt_master_create_domain);
3293 EXPORT_SYMBOL(ecrt_master_activate);
3294 EXPORT_SYMBOL(ecrt_master_deactivate);
3295 EXPORT_SYMBOL(ecrt_master_send);
3296 EXPORT_SYMBOL(ecrt_master_send_ext);
3297 EXPORT_SYMBOL(ecrt_master_receive);
3298 EXPORT_SYMBOL(ecrt_master_callbacks);
3299 EXPORT_SYMBOL(ecrt_master);
3300 EXPORT_SYMBOL(ecrt_master_get_slave);
3301 EXPORT_SYMBOL(ecrt_master_slave_config);
3302 EXPORT_SYMBOL(ecrt_master_select_reference_clock);
3303 EXPORT_SYMBOL(ecrt_master_state);
3304 EXPORT_SYMBOL(ecrt_master_link_state);
3305 EXPORT_SYMBOL(ecrt_master_application_time);
3306 EXPORT_SYMBOL(ecrt_master_sync_reference_clock);
3307 EXPORT_SYMBOL(ecrt_master_sync_reference_clock_to);
3308 EXPORT_SYMBOL(ecrt_master_sync_slave_clocks);
3309 EXPORT_SYMBOL(ecrt_master_reference_clock_time);
3310 EXPORT_SYMBOL(ecrt_master_sync_monitor_queue);
3311 EXPORT_SYMBOL(ecrt_master_sync_monitor_process);
3312 EXPORT_SYMBOL(ecrt_master_sdo_download);
3313 EXPORT_SYMBOL(ecrt_master_sdo_download_complete);
3314 EXPORT_SYMBOL(ecrt_master_sdo_upload);
3315 EXPORT_SYMBOL(ecrt_master_write_idn);
3316 EXPORT_SYMBOL(ecrt_master_read_idn);
3317 EXPORT_SYMBOL(ecrt_master_reset);
3318 
3321 /*****************************************************************************/
ec_eoe_queue
void ec_eoe_queue(ec_eoe_t *eoe)
Queues the datagram, if necessary.
Definition: ethernet.c:358
ec_master::injection_seq_fsm
unsigned int injection_seq_fsm
Datagram injection sequence number for the FSM side.
Definition: master.h:226
ec_slave_info_t::serial_number
uint32_t serial_number
Serial-Number stored on the slave.
Definition: ecrt.h:373
EC_IO_TIMEOUT
#define EC_IO_TIMEOUT
Datagram timeout in microseconds.
Definition: globals.h:47
ec_slave_info_t::desc
ec_slave_port_desc_t desc
Physical port type.
Definition: ecrt.h:377
ec_master::reserved
unsigned int reserved
True, if the master is in use.
Definition: master.h:196
ec_master::ext_datagram_queue
struct list_head ext_datagram_queue
Queue for non-application datagrams.
Definition: master.h:266
ec_slave_info_t::ports
struct ec_slave_info_t::@3 ports[EC_MAX_PORTS]
Port information.
ec_mac_is_zero
int ec_mac_is_zero(const uint8_t *)
Definition: module.c:263
ec_slave::ring_position
uint16_t ring_position
Ring position.
Definition: slave.h:183
ec_sii_t::revision_number
uint32_t revision_number
Revision number.
Definition: slave.h:137
ec_datagram_t::jiffies_sent
unsigned long jiffies_sent
Jiffies, when the datagram was sent.
Definition: datagram.h:104
ec_master_clear_config
void ec_master_clear_config(ec_master_t *master)
Clear the configuration applied by the application.
Definition: master.c:529
EC_ADDR_LEN
#define EC_ADDR_LEN
Size of the EtherCAT address field.
Definition: globals.h:88
ec_slave_sdo_count
uint16_t ec_slave_sdo_count(const ec_slave_t *slave)
Get the number of SDOs in the dictionary.
Definition: slave.c:706
ec_soe_request_set_idn
void ec_soe_request_set_idn(ec_soe_request_t *req, uint16_t idn)
Set IDN.
Definition: soe_request.c:117
ec_rtdm_dev_init
int ec_rtdm_dev_init(ec_rtdm_dev_t *rtdm_dev, ec_master_t *master)
Initialize an RTDM device.
Definition: rtdm.c:69
EC_DATAGRAM_NAME_SIZE
#define EC_DATAGRAM_NAME_SIZE
Size of the datagram description string.
Definition: globals.h:116
ec_slave::sii
ec_sii_t sii
Extracted SII data.
Definition: slave.h:223
ecrt_master_sync_monitor_process
uint32_t ecrt_master_sync_monitor_process(ec_master_t *master)
Processes the DC synchrony monitoring datagram.
Definition: master.c:2853
ec_master::io_sem
struct semaphore io_sem
Semaphore used in IDLE phase.
Definition: master.h:295
ec_device::tx_skb
struct sk_buff * tx_skb[EC_TX_RING_SIZE]
transmit skb ring
Definition: device.h:89
ec_datagram_t::data_size
size_t data_size
Size of the data in data.
Definition: datagram.h:97
ec_master::config_sem
struct semaphore config_sem
Semaphore protecting the config_busy variable and the allow_config flag.
Definition: master.h:258
ec_soe_request_t::data
uint8_t * data
Pointer to SDO data.
Definition: soe_request.h:53
ec_slave_config_init
void ec_slave_config_init(ec_slave_config_t *sc, ec_master_t *master, uint16_t alias, uint16_t position, uint32_t vendor_id, uint32_t product_code)
Slave configuration constructor.
Definition: slave_config.c:55
ec_slave_info_t::sync_count
uint8_t sync_count
Number of sync managers.
Definition: ecrt.h:387
ec_master_calc_dc
void ec_master_calc_dc(ec_master_t *master)
Distributed-clocks calculations.
Definition: master.c:2209
ec_master::fsm_exec_count
unsigned int fsm_exec_count
Number of entries in execution list.
Definition: master.h:283
ec_device_stats_t::last_loss
u64 last_loss
Tx/Rx difference of last statistics cycle.
Definition: master.h:166
ec_device_stats_t::tx_count
u64 tx_count
Number of frames sent.
Definition: master.h:156
rate_intervals
const unsigned int rate_intervals[]
List of intervals for statistics [s].
Definition: master.c:96
ec_slave_info_t::error_flag
uint8_t error_flag
Error flag for that slave.
Definition: ecrt.h:386
ec_master_clear
void ec_master_clear(ec_master_t *master)
Destructor.
Definition: master.c:389
ec_soe_request_t::list
struct list_head list
List item.
Definition: soe_request.h:49
ec_master::sii_requests
struct list_head sii_requests
SII write requests.
Definition: master.h:306
ecrt_master_sync_slave_clocks
void ecrt_master_sync_slave_clocks(ec_master_t *master)
Queues the DC clock drift compensation datagram for sending.
Definition: master.c:2835
EC_SLAVE_DBG
#define EC_SLAVE_DBG(slave, level, fmt, args...)
Convenience macro for printing slave-specific debug messages to syslog.
Definition: slave.h:106
ec_domain::data_size
size_t data_size
Size of the process data.
Definition: domain.h:61
ec_device::jiffies_poll
unsigned long jiffies_poll
jiffies of last poll
Definition: device.h:97
ec_eoe::slave
ec_slave_t * slave
pointer to the corresponding slave
Definition: ethernet.h:79
ec_master_queue_datagram_ext
void ec_master_queue_datagram_ext(ec_master_t *master, ec_datagram_t *datagram)
Places a datagram in the non-application datagram queue.
Definition: master.c:973
EC_SLAVE_STATE_OP
OP (mailbox communication and input/output update)
Definition: globals.h:138
ec_device_stats_t::tx_byte_rates
s32 tx_byte_rates[EC_RATE_COUNT]
Transmit rates in byte/s for different statistics cycle periods.
Definition: master.h:173
ec_sii_write_request_t::state
ec_internal_request_state_t state
State of the request.
Definition: fsm_master.h:59
ec_master_get_config
ec_slave_config_t * ec_master_get_config(const ec_master_t *master, unsigned int pos)
Get a slave configuration via its position in the list.
Definition: master.c:1899
ec_fsm_master::slaves_responding
unsigned int slaves_responding[EC_MAX_NUM_DEVICES]
Number of responding slaves for every device.
Definition: fsm_master.h:80
ecrt_master_link_state
int ecrt_master_link_state(const ec_master_t *master, unsigned int dev_idx, ec_master_link_state_t *state)
Reads the current state of a redundant link.
Definition: master.c:2766
ec_slave::ports
ec_slave_port_t ports[EC_MAX_PORTS]
Ports.
Definition: slave.h:187
ecrt_master_application_time
void ecrt_master_application_time(ec_master_t *master, uint64_t app_time)
Sets the application time.
Definition: master.c:2782
ec_fsm_master_reset
void ec_fsm_master_reset(ec_fsm_master_t *fsm)
Reset state machine.
Definition: fsm_master.c:121
ec_master_request_op
void ec_master_request_op(ec_master_t *master)
Request OP state for configured slaves.
Definition: master.c:2226
ec_master_eoe_thread
static int ec_master_eoe_thread(void *)
Does the Ethernet over EtherCAT processing.
Definition: master.c:1730
ec_fsm_slave_is_ready
int ec_fsm_slave_is_ready(const ec_fsm_slave_t *fsm)
Returns, if the FSM is currently not busy and ready to execute.
Definition: fsm_slave.c:164
ec_sdo_request
CANopen SDO request.
Definition: sdo_request.h:48
ec_master_info_t::slave_count
unsigned int slave_count
Number of slaves in the bus.
Definition: ecrt.h:333
ec_slave::current_state
ec_slave_state_t current_state
Current application state.
Definition: slave.h:192
ec_master_leave_operation_phase
void ec_master_leave_operation_phase(ec_master_t *master)
Transition function from OPERATION to IDLE phase.
Definition: master.c:768
ec_master_num_devices
#define ec_master_num_devices(MASTER)
Number of Ethernet devices.
Definition: master.h:329
EC_RATE_COUNT
#define EC_RATE_COUNT
Number of statistic rate intervals to maintain.
Definition: globals.h:72
ec_master::sync_mon_datagram
ec_datagram_t sync_mon_datagram
Datagram used for DC synchronisation monitoring.
Definition: master.h:244
slave.h
EtherCAT slave structure.
ec_sdo_request::state
ec_internal_request_state_t state
SDO request state.
Definition: sdo_request.h:63
ec_slave_info_t::vendor_id
uint32_t vendor_id
Vendor-ID stored on the slave.
Definition: ecrt.h:370
ec_device_clear
void ec_device_clear(ec_device_t *device)
Destructor.
Definition: device.c:162
ecrt_master_sdo_download_complete
int ecrt_master_sdo_download_complete(ec_master_t *master, uint16_t slave_position, uint16_t index, uint8_t *data, size_t data_size, uint32_t *abort_code)
Executes an SDO download request to write data to a slave via complete access.
Definition: master.c:2948
ec_domain::list
struct list_head list
List item.
Definition: domain.h:56
ec_master::eoe_handlers
struct list_head eoe_handlers
Ethernet over EtherCAT handlers.
Definition: master.h:292
ec_master_link_state_t
Redundant link state.
Definition: ecrt.h:286
ec_slave_config::product_code
uint32_t product_code
Slave product code.
Definition: slave_config.h:126
ec_slave_info_t::link
ec_slave_port_link_t link
Port link state.
Definition: ecrt.h:378
ec_master_link_state_t::slaves_responding
unsigned int slaves_responding
Sum of responding slaves on the given link.
Definition: ecrt.h:287
ec_master_thread_start
int ec_master_thread_start(ec_master_t *master, int(*thread_func)(void *), const char *name)
Starts the master thread.
Definition: master.c:574
EC_OPERATION
Operation phase.
Definition: master.h:135
device_number
dev_t device_number
Device number for master cdevs.
Definition: module.c:66
ec_slave_port_t::link
ec_slave_port_link_t link
Port link status.
Definition: slave.h:120
ec_master::allow_scan
unsigned int allow_scan
True, if slave scanning is allowed.
Definition: master.h:251
ec_master::max_queue_size
size_t max_queue_size
Maximum size of datagram queue.
Definition: master.h:279
ec_master_internal_receive_cb
void ec_master_internal_receive_cb(void *cb_data)
Internal receiving callback.
Definition: master.c:557
ec_slave_config::position
uint16_t position
Index after alias.
Definition: slave_config.h:123
ec_master_operation_thread
static int ec_master_operation_thread(void *)
Master kernel thread function for OPERATION phase.
Definition: master.c:1627
ec_soe_request_read
void ec_soe_request_read(ec_soe_request_t *req)
Request a read operation.
Definition: soe_request.c:232
ec_master_find_slave_const
const ec_slave_t * ec_master_find_slave_const(const ec_master_t *master, uint16_t alias, uint16_t position)
Finds a slave in the bus, given the alias and position.
Definition: master.c:1850
EC_FRAME_HEADER_SIZE
#define EC_FRAME_HEADER_SIZE
Size of an EtherCAT frame header.
Definition: globals.h:79
ecrt_master_callbacks
void ecrt_master_callbacks(ec_master_t *master, void(*send_cb)(void *), void(*receive_cb)(void *), void *cb_data)
Sets the locking callbacks.
Definition: master.c:2729
ec_datagram_t
EtherCAT datagram.
Definition: datagram.h:87
ec_slave_config::list
struct list_head list
List item.
Definition: slave_config.h:119
ec_sii_t::serial_number
uint32_t serial_number
Serial number.
Definition: slave.h:138
ecrt_master_get_slave
int ecrt_master_get_slave(ec_master_t *master, uint16_t slave_position, ec_slave_info_t *slave_info)
Obtains slave information.
Definition: master.c:2667
ec_master::fsm_exec_list
struct list_head fsm_exec_list
Slave FSM execution list.
Definition: master.h:282
ec_master_find_domain_const
const ec_domain_t * ec_master_find_domain_const(const ec_master_t *master, unsigned int index)
Get a domain via its position in the list.
Definition: master.c:1978
ec_master_get_eoe_handler_const
const ec_eoe_t * ec_master_get_eoe_handler_const(const ec_master_t *master, uint16_t index)
Get an EoE handler via its position in the list.
Definition: master.c:2017
EC_WRITE_U8
#define EC_WRITE_U8(DATA, VAL)
Write an 8-bit unsigned value to EtherCAT data.
Definition: ecrt.h:2231
ec_sdo_request::abort_code
uint32_t abort_code
SDO request abort code.
Definition: sdo_request.h:68
ec_master::dc_ref_time
u64 dc_ref_time
Common reference timestamp for DC start times.
Definition: master.h:239
ec_fsm_master::slave_states
ec_slave_state_t slave_states[EC_MAX_NUM_DEVICES]
AL states of responding slaves for every device.
Definition: fsm_master.h:84
ec_master::emerg_reg_requests
struct list_head emerg_reg_requests
Emergency register access requests.
Definition: master.h:307
ec_soe_request_t::state
ec_internal_request_state_t state
Request state.
Definition: soe_request.h:58
ec_datagram_t::name
char name[EC_DATAGRAM_NAME_SIZE]
Description of the datagram.
Definition: datagram.h:112
ec_slave_config::alias
uint16_t alias
Slave alias.
Definition: slave_config.h:122
ec_master_send_datagrams
void ec_master_send_datagrams(ec_master_t *master, ec_device_index_t device_index)
Sends the datagrams in the queue for a certain device.
Definition: master.c:988
ec_device_update_stats
void ec_device_update_stats(ec_device_t *device)
Update device statistics.
Definition: device.c:496
ec_master::domains
struct list_head domains
List of domains.
Definition: master.h:236
ec_fsm_slave
Finite state machine of an EtherCAT slave.
Definition: fsm_slave.h:54
ec_fsm_slave::datagram
ec_datagram_t * datagram
Previous state datagram.
Definition: fsm_slave.h:59
ec_master_link_state_t::link_up
unsigned int link_up
true, if the given Ethernet link is up.
Definition: ecrt.h:298
ec_slave_info_t::delay_to_next_dc
uint32_t delay_to_next_dc
Delay [ns] to next DC slave.
Definition: ecrt.h:383
ec_slave::fsm
ec_fsm_slave_t fsm
Slave state machine.
Definition: slave.h:234
EC_FIND_CONFIG
#define EC_FIND_CONFIG
Common implementation for ec_master_get_config() and ec_master_get_config_const().
Definition: master.c:1885
ec_soe_request_t::error_code
uint16_t error_code
SoE error code.
Definition: soe_request.h:61
ecrt_master_send_ext
void ecrt_master_send_ext(ec_master_t *master)
Sends non-application datagrams.
Definition: master.c:2547
ec_datagram_t::working_counter
uint16_t working_counter
Working counter.
Definition: datagram.h:99
ecrt_master_create_domain
ec_domain_t * ecrt_master_create_domain(ec_master_t *master)
Creates a new process data domain.
Definition: master.c:2297
ec_sdo_request::data
uint8_t * data
Pointer to SDO data.
Definition: sdo_request.h:52
ec_device_stats_t::jiffies
unsigned long jiffies
Jiffies of last statistic cycle.
Definition: master.h:179
ec_sii_t::current_on_ebus
int16_t current_on_ebus
Power consumption in mA.
Definition: slave.h:162
ec_master_find_slave
ec_slave_t * ec_master_find_slave(ec_master_t *master, uint16_t alias, uint16_t position)
Finds a slave in the bus, given the alias and position.
Definition: master.c:1834
ec_device::link_state
uint8_t link_state
device link state
Definition: device.h:88
debug_level
static unsigned int debug_level
Debug level parameter.
Definition: module.c:61
ec_device_stats_t::last_rx_count
u64 last_rx_count
Number of frames received of last statistics cycle.
Definition: master.h:159
ec_slave_port_link_t::signal_detected
uint8_t signal_detected
Detected signal on RX port.
Definition: ecrt.h:357
ec_master::macs
const uint8_t * macs[EC_MAX_NUM_DEVICES]
Device MAC addresses.
Definition: master.h:212
EC_DATAGRAM_SENT
Sent (still in the queue).
Definition: datagram.h:77
ec_master_state_t::slaves_responding
unsigned int slaves_responding
Sum of responding slaves on all Ethernet devices.
Definition: ecrt.h:263
ecrt_master_state
void ecrt_master_state(const ec_master_t *master, ec_master_state_t *state)
Reads the current master state.
Definition: master.c:2743
ec_master::request_queue
wait_queue_head_t request_queue
Wait queue for external requests from user space.
Definition: master.h:310
ec_master_clear_device_stats
void ec_master_clear_device_stats(ec_master_t *)
Clears the common device statistics.
Definition: master.c:1293
ecrt_master_sync_reference_clock_to
void ecrt_master_sync_reference_clock_to(ec_master_t *master, uint64_t sync_time)
Queues the DC reference clock drift compensation datagram for sending.
Definition: master.c:2822
ec_slave::station_address
uint16_t station_address
Configured station address.
Definition: slave.h:184
ec_sii_t::sync_count
unsigned int sync_count
Number of sync managers.
Definition: slave.h:166
ec_sii_write_request_t::list
struct list_head list
List head.
Definition: fsm_master.h:54
ec_sii_write_request_t
SII write request.
Definition: fsm_master.h:53
ec_slave_clear
void ec_slave_clear(ec_slave_t *slave)
Slave destructor.
Definition: slave.c:170
ecrt_master_create_domain_err
ec_domain_t * ecrt_master_create_domain_err(ec_master_t *master)
Same as ecrt_master_create_domain(), but with ERR_PTR() return value.
Definition: master.c:2260
ec_master_info_t::link_up
unsigned int link_up
true, if the network link is up.
Definition: ecrt.h:334
ec_datagram_output_stats
void ec_datagram_output_stats(ec_datagram_t *datagram)
Outputs datagram statistics at most every second.
Definition: datagram.c:619
ec_master_enter_idle_phase
int ec_master_enter_idle_phase(ec_master_t *master)
Transition function from ORPHANED to IDLE phase.
Definition: master.c:629
ec_datagram_t::type
ec_datagram_type_t type
Datagram type (APRD, BWR, etc.).
Definition: datagram.h:92
ec_master_get_config_const
const ec_slave_config_t * ec_master_get_config_const(const ec_master_t *master, unsigned int pos)
Get a slave configuration via its position in the list.
Definition: master.c:1914
globals.h
Global definitions and macros.
ec_slave_info_t::revision_number
uint32_t revision_number
Revision-Number stored on the slave.
Definition: ecrt.h:372
EC_DATAGRAM_LWR
Logical Write.
Definition: datagram.h:62
master.h
EtherCAT master structure.
ec_master::cb_data
void * cb_data
Current callback data.
Definition: master.h:299
ec_device_send
void ec_device_send(ec_device_t *device, size_t size)
Sends the content of the transmit socket buffer.
Definition: device.c:331
ec_fsm_master_init
void ec_fsm_master_init(ec_fsm_master_t *fsm, ec_master_t *master, ec_datagram_t *datagram)
Constructor.
Definition: fsm_master.c:76
EC_DATAGRAM_INIT
Initial state of a new datagram.
Definition: datagram.h:75
EC_MASTER_DBG
#define EC_MASTER_DBG(master, level, fmt, args...)
Convenience macro for printing master-specific debug messages to syslog.
Definition: master.h:111
ec_master::fsm_slave
ec_slave_t * fsm_slave
Slave that is queried next for FSM exec.
Definition: master.h:281
ec_master::send_interval
unsigned int send_interval
Interval between two calls to ecrt_master_send().
Definition: master.h:277
ec_sii_write_request_t::slave
ec_slave_t * slave
EtherCAT slave.
Definition: fsm_master.h:55
ec_slave
EtherCAT slave.
Definition: slave.h:176
ec_master::master_sem
struct semaphore master_sem
Master semaphore.
Definition: master.h:209
ec_slave_port_link_t::loop_closed
uint8_t loop_closed
Loop closed.
Definition: ecrt.h:356
ec_master::datagram_index
uint8_t datagram_index
Current datagram index.
Definition: master.h:264
ec_master_attach_slave_configs
void ec_master_attach_slave_configs(ec_master_t *master)
Attaches the slave configurations to the slaves.
Definition: master.c:1794
ec_master::datagram_queue
struct list_head datagram_queue
Datagram queue.
Definition: master.h:263
ec_fsm_slave::slave
ec_slave_t * slave
slave the FSM runs on
Definition: fsm_slave.h:55
ecrt_sdo_request_read
void ecrt_sdo_request_read(ec_sdo_request_t *req)
Schedule an SDO read operation.
Definition: sdo_request.c:224
ec_slave_info_t::name
char name[EC_MAX_STRING_LENGTH]
Name of the slave.
Definition: ecrt.h:389
ec_sdo_request_clear
void ec_sdo_request_clear(ec_sdo_request_t *req)
SDO request destructor.
Definition: sdo_request.c:76
ec_master::eoe_thread
struct task_struct * eoe_thread
EoE thread.
Definition: master.h:291
ec_slave::sdo_requests
struct list_head sdo_requests
SDO access requests.
Definition: slave.h:229
ec_master_state_t
Master state.
Definition: ecrt.h:262
ec_stats_t::unmatched
unsigned int unmatched
unmatched datagrams (received, but not queued any longer)
Definition: master.h:146
ec_master::ext_ring_idx_fsm
unsigned int ext_ring_idx_fsm
Index in external datagram ring for FSM side.
Definition: master.h:275
ec_datagram_zero
void ec_datagram_zero(ec_datagram_t *datagram)
Fills the datagram payload memory with zeros.
Definition: datagram.c:178
ec_master_debug_level
int ec_master_debug_level(ec_master_t *master, unsigned int level)
Set the debug level.
Definition: master.c:2042
ec_device_stats_t::tx_frame_rates
s32 tx_frame_rates[EC_RATE_COUNT]
Transmit rates in frames/s for different statistics cycle periods.
Definition: master.h:167
ec_master_info_t::app_time
uint64_t app_time
Application time.
Definition: ecrt.h:336
ec_device_stats_t::rx_byte_rates
s32 rx_byte_rates[EC_RATE_COUNT]
Receive rates in byte/s for different statistics cycle periods.
Definition: master.h:175
ethernet.h
Ethernet over EtherCAT (EoE)
ec_slave::soe_requests
struct list_head soe_requests
SoE write requests.
Definition: slave.h:232
EC_DATAGRAM_HEADER_SIZE
#define EC_DATAGRAM_HEADER_SIZE
Size of an EtherCAT datagram header.
Definition: globals.h:82
ec_datagram_t::state
ec_datagram_state_t state
State.
Definition: datagram.h:100
ec_master::device_stats
ec_device_stats_t device_stats
Device statistics.
Definition: master.h:219
ec_master::fsm_datagram
ec_datagram_t fsm_datagram
Datagram used for state machines.
Definition: master.h:222
ec_slave::config
ec_slave_config_t * config
Current configuration.
Definition: slave.h:190
ec_master::phase
ec_master_phase_t phase
Master phase.
Definition: master.h:223
EC_WRITE_U32
#define EC_WRITE_U32(DATA, VAL)
Write a 32-bit unsigned value to EtherCAT data.
Definition: ecrt.h:2265
ec_master::slaves
ec_slave_t * slaves
Array of slaves on the bus.
Definition: master.h:231
ec_domain_clear
void ec_domain_clear(ec_domain_t *domain)
Domain destructor.
Definition: domain.c:88
ec_soe_request_set_drive_no
void ec_soe_request_set_drive_no(ec_soe_request_t *req, uint8_t drive_no)
Set drive number.
Definition: soe_request.c:105
ec_slave_calc_port_delays
void ec_slave_calc_port_delays(ec_slave_t *slave)
Calculates the port transmission delays.
Definition: slave.c:922
ec_domain_finish
int ec_domain_finish(ec_domain_t *domain, uint32_t base_address)
Finishes a domain.
Definition: domain.c:226
ext_injection_timeout_jiffies
static unsigned long ext_injection_timeout_jiffies
Timeout for external datagram injection [jiffies].
Definition: master.c:90
ec_master::device_sem
struct semaphore device_sem
Device semaphore.
Definition: master.h:218
ec_eoe_is_idle
int ec_eoe_is_idle(const ec_eoe_t *eoe)
Returns the idle state.
Definition: ethernet.c:384
ecrt_master_sdo_download
int ecrt_master_sdo_download(ec_master_t *master, uint16_t slave_position, uint16_t index, uint8_t subindex, uint8_t *data, size_t data_size, uint32_t *abort_code)
Executes an SDO download request to write data to a slave.
Definition: master.c:2864
ec_device
EtherCAT device.
Definition: device.h:81
ec_master_find_domain
ec_domain_t * ec_master_find_domain(ec_master_t *master, unsigned int index)
Get a domain via its position in the list.
Definition: master.c:1963
ec_device::tx_ring_index
unsigned int tx_ring_index
last ring entry used to transmit
Definition: device.h:90
ec_soe_request_t::data_size
size_t data_size
Size of SDO data.
Definition: soe_request.h:55
ec_stats_t::timeouts
unsigned int timeouts
datagram timeouts
Definition: master.h:144
ec_fsm_master::sdo_request
ec_sdo_request_t * sdo_request
SDO request to process.
Definition: fsm_master.h:90
ec_master::debug_level
unsigned int debug_level
Master debug level.
Definition: master.h:285
ec_datagram_frmw
int ec_datagram_frmw(ec_datagram_t *datagram, uint16_t configured_address, uint16_t mem_address, size_t data_size)
Initializes an EtherCAT FRMW datagram.
Definition: datagram.c:348
EC_SLAVE_ERR
#define EC_SLAVE_ERR(slave, fmt, args...)
Convenience macro for printing slave-specific errors to syslog.
Definition: slave.h:76
ec_master_domain_count
unsigned int ec_master_domain_count(const ec_master_t *master)
Get the number of domains.
Definition: master.c:1929
EC_ORPHANED
Orphaned phase.
Definition: master.h:131
ec_device_stats_t::loss_rates
s32 loss_rates[EC_RATE_COUNT]
Frame loss rates for different statistics cycle periods.
Definition: master.h:177
ec_stats_t::corrupted
unsigned int corrupted
corrupted frames
Definition: master.h:145
ec_device_stats_t::last_tx_count
u64 last_tx_count
Number of frames sent of last statistics cycle.
Definition: master.h:157
ec_slave::transmission_delay
uint32_t transmission_delay
DC system time transmission delay (offset from reference clock).
Definition: slave.h:215
ecrt_master_select_reference_clock
int ecrt_master_select_reference_clock(ec_master_t *master, ec_slave_config_t *sc)
Selects the reference clock for distributed clocks.
Definition: master.c:2633
ec_master_exec_slave_fsms
void ec_master_exec_slave_fsms(ec_master_t *master)
Execute slave FSMs.
Definition: master.c:1466
ec_soe_request_clear
void ec_soe_request_clear(ec_soe_request_t *req)
SoE request destructor.
Definition: soe_request.c:77
ec_master::ext_ring_idx_rt
unsigned int ext_ring_idx_rt
Index in external datagram ring for RT side.
Definition: master.h:273
ec_master::slave_count
unsigned int slave_count
Number of slaves on the bus.
Definition: master.h:232
ec_master::scan_busy
unsigned int scan_busy
Current scan state.
Definition: master.h:250
ec_device_index_t
ec_device_index_t
Master devices.
Definition: globals.h:201
ec_master::receive_cb
void(* receive_cb)(void *)
Current receive datagrams callback.
Definition: master.h:298
ec_device_stats_t::rx_frame_rates
s32 rx_frame_rates[EC_RATE_COUNT]
Receive rates in frames/s for different statistics cycle periods.
Definition: master.h:170
EC_WRITE_U16
#define EC_WRITE_U16(DATA, VAL)
Write a 16-bit unsigned value to EtherCAT data.
Definition: ecrt.h:2248
ec_domain::index
unsigned int index
Index (just a number).
Definition: domain.h:58
ec_slave_calc_transmission_delays_rec
void ec_slave_calc_transmission_delays_rec(ec_slave_t *slave, uint32_t *delay)
Recursively calculates transmission delays.
Definition: slave.c:968
ec_master_leave_idle_phase
void ec_master_leave_idle_phase(ec_master_t *master)
Transition function from IDLE to ORPHANED phase.
Definition: master.c:662
EC_DEVICE_MAIN
Main device.
Definition: globals.h:202
ec_datagram_t::skip_count
unsigned int skip_count
Number of requeues when not yet received.
Definition: datagram.h:110
ec_master_init
int ec_master_init(ec_master_t *master, unsigned int index, const uint8_t *main_mac, const uint8_t *backup_mac, dev_t device_number, struct class *class, unsigned int debug_level)
Master constructor.
Definition: master.c:138
EC_READ_U32
#define EC_READ_U32(DATA)
Read a 32-bit unsigned value from EtherCAT data.
Definition: ecrt.h:2159
ec_device_init
int ec_device_init(ec_device_t *device, ec_master_t *master)
Constructor.
Definition: device.c:63
ec_slave_port_t::desc
ec_slave_port_desc_t desc
Port descriptors.
Definition: slave.h:119
EC_MASTER_WARN
#define EC_MASTER_WARN(master, fmt, args...)
Convenience macro for printing master-specific warnings to syslog.
Definition: master.h:97
ec_fsm_slave_exec
int ec_fsm_slave_exec(ec_fsm_slave_t *fsm, ec_datagram_t *datagram)
Executes the current state of the state machine.
Definition: fsm_slave.c:123
ec_master::active
unsigned int active
Master has been activated.
Definition: master.h:224
ec_datagram_t::sent
struct list_head sent
Master list item for sent datagrams.
Definition: datagram.h:89
ec_sdo_request::errno
int errno
Error number.
Definition: sdo_request.h:67
ec_datagram_brd
int ec_datagram_brd(ec_datagram_t *datagram, uint16_t mem_address, size_t data_size)
Initializes an EtherCAT BRD datagram.
Definition: datagram.c:373
ec_datagram_fpwr
int ec_datagram_fpwr(ec_datagram_t *datagram, uint16_t configured_address, uint16_t mem_address, size_t data_size)
Initializes an EtherCAT FPWR datagram.
Definition: datagram.c:298
ec_master_enter_operation_phase
int ec_master_enter_operation_phase(ec_master_t *master)
Transition function from IDLE to OPERATION phase.
Definition: master.c:686
ecrt_master_sdo_upload
int ecrt_master_sdo_upload(ec_master_t *master, uint16_t slave_position, uint16_t index, uint8_t subindex, uint8_t *target, size_t target_size, size_t *result_size, uint32_t *abort_code)
Executes an SDO upload request to read data from a slave.
Definition: master.c:3034
ec_slave::has_dc_system_time
uint8_t has_dc_system_time
The slave supports the DC system time register.
Definition: slave.h:212
ec_master::scan_queue
wait_queue_head_t scan_queue
Queue for processes that wait for slave scanning.
Definition: master.h:254
ec_master::sync_datagram
ec_datagram_t sync_datagram
Datagram used for DC drift compensation.
Definition: master.h:242
EC_MASTER_ERR
#define EC_MASTER_ERR(master, fmt, args...)
Convenience macro for printing master-specific errors to syslog.
Definition: master.h:85
ec_master::class_device
struct device * class_device
Master class device.
Definition: master.h:200
datagram.h
EtherCAT datagram structure.
ec_master_queue_datagram
void ec_master_queue_datagram(ec_master_t *master, ec_datagram_t *datagram)
Places a datagram in the datagram queue.
Definition: master.c:940
ec_slave_config_attach
int ec_slave_config_attach(ec_slave_config_t *sc)
Attaches the configuration to the addressed slave object.
Definition: slave_config.c:208
EC_DATAGRAM_BWR
Broadcast Write.
Definition: datagram.h:59
ec_master_idle_thread
static int ec_master_idle_thread(void *)
Master kernel thread function for IDLE phase.
Definition: master.c:1556
ec_master::configs
struct list_head configs
List of slave configurations.
Definition: master.h:235
ec_slave_config::slave
ec_slave_t * slave
Slave pointer.
Definition: slave_config.h:133
ec_master::dc_ref_config
ec_slave_config_t * dc_ref_config
Application-selected DC reference clock slave config.
Definition: master.h:246
ec_datagram_t::device_index
ec_device_index_t device_index
Device via which the datagram shall be / was sent.
Definition: datagram.h:90
ec_soe_request_alloc
int ec_soe_request_alloc(ec_soe_request_t *req, size_t size)
Pre-allocates the data memory.
Definition: soe_request.c:150
ecrt_master_reset
void ecrt_master_reset(ec_master_t *master)
Retry configuring slaves.
Definition: master.c:3277
ec_fsm_master_idle
int ec_fsm_master_idle(const ec_fsm_master_t *fsm)
Definition: fsm_master.c:169
ec_master_clear_slaves
void ec_master_clear_slaves(ec_master_t *master)
Clear all slaves.
Definition: master.c:472
ec_slave_info_t
Slave information.
Definition: ecrt.h:368
ecrt_master_sync_monitor_queue
void ecrt_master_sync_monitor_queue(ec_master_t *master)
Queues the DC synchrony monitoring datagram for sending.
Definition: master.c:2845
ec_eoe::list
struct list_head list
list item
Definition: ethernet.h:78
ec_device_stats_t
Device statistics.
Definition: master.h:155
ec_device_tx_data
uint8_t * ec_device_tx_data(ec_device_t *device)
Returns a pointer to the device&#39;s transmit memory.
Definition: device.c:312
ec_device_stats_t::last_rx_bytes
u64 last_rx_bytes
Number of bytes received of last statistics cycle.
Definition: master.h:164
ec_stats_t::output_jiffies
unsigned long output_jiffies
time of last output
Definition: master.h:148
ec_master::stats
ec_stats_t stats
Cyclic statistics.
Definition: master.h:286
ec_print_data
void ec_print_data(const uint8_t *, size_t)
Outputs frame contents for debugging purposes.
Definition: module.c:341
EC_IDLE
Idle phase.
Definition: master.h:133
ec_master_update_device_stats
void ec_master_update_device_stats(ec_master_t *)
Updates the common device statistics.
Definition: master.c:1325
ec_master::scan_sem
struct semaphore scan_sem
Semaphore protecting the scan_busy variable and the allow_scan flag.
Definition: master.h:252
ec_datagram_prealloc
int ec_datagram_prealloc(ec_datagram_t *datagram, size_t size)
Allocates internal payload memory.
Definition: datagram.c:150
ec_slave::effective_alias
uint16_t effective_alias
Effective alias address.
Definition: slave.h:185
ec_master_calc_transmission_delays
void ec_master_calc_transmission_delays(ec_master_t *master)
Calculates the bus transmission delays.
Definition: master.c:2187
ec_master_clear_eoe_handlers
void ec_master_clear_eoe_handlers(ec_master_t *master)
Clear and free all EoE handlers.
Definition: master.c:436
ec_slave_info_t::al_state
uint8_t al_state
Current state of the slave.
Definition: ecrt.h:385
ec_sdo_request::data_size
size_t data_size
Size of SDO data.
Definition: sdo_request.h:54
ecrt_master_slave_config
ec_slave_config_t * ecrt_master_slave_config(ec_master_t *master, uint16_t alias, uint16_t position, uint32_t vendor_id, uint32_t product_code)
Obtains a slave configuration.
Definition: master.c:2622
ec_master_info_t::scan_busy
uint8_t scan_busy
true, while the master is scanning the bus
Definition: ecrt.h:335
ecrt_master_read_idn
int ecrt_master_read_idn(ec_master_t *master, uint16_t slave_position, uint8_t drive_no, uint16_t idn, uint8_t *target, size_t target_size, size_t *result_size, uint16_t *error_code)
Executes an SoE read request.
Definition: master.c:3193
EC_READ_U16
#define EC_READ_U16(DATA)
Read a 16-bit unsigned value from EtherCAT data.
Definition: ecrt.h:2143
ec_master_eoe_start
void ec_master_eoe_start(ec_master_t *master)
Starts Ethernet over EtherCAT processing on demand.
Definition: master.c:1681
ec_device_stats_t::tx_bytes
u64 tx_bytes
Number of bytes sent.
Definition: master.h:161
ec_master::app_send_cb
void(* app_send_cb)(void *)
Application&#39;s send datagrams callback.
Definition: master.h:300
ec_master::app_cb_data
void * app_cb_data
Application callback data.
Definition: master.h:304
ecrt_master_activate
int ecrt_master_activate(ec_master_t *master)
Finishes the configuration phase and prepares for cyclic operation.
Definition: master.c:2307
ec_master_eoe_handler_count
uint16_t ec_master_eoe_handler_count(const ec_master_t *master)
Get the number of EoE handlers.
Definition: master.c:1995
ec_slave_info_t::current_on_ebus
int16_t current_on_ebus
Used current in mA.
Definition: ecrt.h:375
ec_master_clear_slave_configs
void ec_master_clear_slave_configs(ec_master_t *)
Clear all slave configurations.
Definition: master.c:454
ec_master_clear_domains
void ec_master_clear_domains(ec_master_t *)
Clear all domains.
Definition: master.c:514
ec_master_find_dc_ref_clock
void ec_master_find_dc_ref_clock(ec_master_t *)
Finds the DC reference clock.
Definition: master.c:2065
ec_fsm_slave::list
struct list_head list
Used for execution list.
Definition: fsm_slave.h:56
ec_master_thread_stop
void ec_master_thread_stop(ec_master_t *master)
Stops the master thread.
Definition: master.c:597
ec_sdo_request_init
void ec_sdo_request_init(ec_sdo_request_t *req)
SDO request constructor.
Definition: sdo_request.c:56
EC_MAX_PORTS
#define EC_MAX_PORTS
Maximum number of slave ports.
Definition: ecrt.h:213
ec_master_get_external_datagram
ec_datagram_t * ec_master_get_external_datagram(ec_master_t *master)
Searches for a free datagram in the external datagram ring.
Definition: master.c:921
ec_master::ext_datagram_ring
ec_datagram_t ext_datagram_ring[EC_EXT_RING_SIZE]
External datagram ring.
Definition: master.h:271
ec_slave_info_t::sdo_count
uint16_t sdo_count
Number of SDOs.
Definition: ecrt.h:388
ec_sdo_request::list
struct list_head list
List item.
Definition: sdo_request.h:49
EC_MAX_STRING_LENGTH
#define EC_MAX_STRING_LENGTH
Maximum string length.
Definition: ecrt.h:210
ec_datagram_init
void ec_datagram_init(ec_datagram_t *datagram)
Constructor.
Definition: datagram.c:88
timeout_jiffies
static unsigned long timeout_jiffies
Frame timeout in jiffies.
Definition: master.c:86
ec_rtdm_dev_clear
void ec_rtdm_dev_clear(ec_rtdm_dev_t *rtdm_dev)
Clear an RTDM device.
Definition: rtdm.c:118
ec_cdev_clear
void ec_cdev_clear(ec_cdev_t *cdev)
Destructor.
Definition: cdev.c:142
ec_slave_port_t::next_slave
ec_slave_t * next_slave
Connected slaves.
Definition: slave.h:121
EC_DATAGRAM_QUEUED
Queued for sending.
Definition: datagram.h:76
ec_master_state_t::link_up
unsigned int link_up
true, if at least one Ethernet link is up.
Definition: ecrt.h:274
ec_slave_config::vendor_id
uint32_t vendor_id
Slave vendor ID.
Definition: slave_config.h:125
ec_slave_port_t::receive_time
uint32_t receive_time
Port receive times for delay measurement.
Definition: slave.h:122
EC_DATAGRAM_TIMED_OUT
Timed out (dequeued).
Definition: datagram.h:79
ec_master::config_queue
wait_queue_head_t config_queue
Queue for processes that wait for slave configuration.
Definition: master.h:260
EC_EXT_RING_SIZE
#define EC_EXT_RING_SIZE
Size of the external datagram ring.
Definition: master.h:124
ec_master_internal_send_cb
void ec_master_internal_send_cb(void *cb_data)
Internal sending callback.
Definition: master.c:543
ec_master_calc_topology_rec
int ec_master_calc_topology_rec(ec_master_t *master, ec_slave_t *port0_slave, unsigned int *slave_position)
Calculates the bus topology; recursion function.
Definition: master.c:2127
ec_slave_info_t::next_slave
uint16_t next_slave
Ring position of next DC slave on that port.
Definition: ecrt.h:381
ec_master_calc_topology
void ec_master_calc_topology(ec_master_t *master)
Calculates the bus topology.
Definition: master.c:2170
ec_master::app_time
u64 app_time
Time of the last ecrt_master_sync() call.
Definition: master.h:238
ec_slave_request_state
void ec_slave_request_state(ec_slave_t *slave, ec_slave_state_t state)
Request a slave state and resets the error flag.
Definition: slave.c:296
ec_master::ref_sync_datagram
ec_datagram_t ref_sync_datagram
Datagram used for synchronizing the reference clock to the master clock.
Definition: master.h:240
ec_master_output_stats
void ec_master_output_stats(ec_master_t *master)
Output master statistics.
Definition: master.c:1263
ec_slave::base_dc_supported
uint8_t base_dc_supported
Distributed clocks are supported.
Definition: slave.h:210
EC_FIND_DOMAIN
#define EC_FIND_DOMAIN
Common implementation for ec_master_find_domain() and ec_master_find_domain_const().
Definition: master.c:1948
ec_device_stats_t::rx_count
u64 rx_count
Number of frames received.
Definition: master.h:158
ecrt_master_deactivate
void ecrt_master_deactivate(ec_master_t *master)
Deactivates the master.
Definition: master.c:2381
ec_master_state_t::al_states
unsigned int al_states
Application-layer states of all slaves.
Definition: ecrt.h:265
ec_datagram_t::data
uint8_t * data
Datagram payload.
Definition: datagram.h:94
EC_FIND_SLAVE
#define EC_FIND_SLAVE
Common implementation for ec_master_find_slave() and ec_master_find_slave_const().
Definition: master.c:1810
ec_master::ext_queue_sem
struct semaphore ext_queue_sem
Semaphore protecting the ext_datagram_queue.
Definition: master.h:268
EC_BYTE_TRANSMISSION_TIME_NS
#define EC_BYTE_TRANSMISSION_TIME_NS
Time to send a byte in nanoseconds.
Definition: globals.h:56
ec_slave_info_t::alias
uint16_t alias
The slaves alias if not equal to 0.
Definition: ecrt.h:374
ecrt_master
int ecrt_master(ec_master_t *master, ec_master_info_t *master_info)
Obtains master information.
Definition: master.c:2653
ec_eoe_run
void ec_eoe_run(ec_eoe_t *eoe)
Runs the EoE state machine.
Definition: ethernet.c:330
EC_READ_U8
#define EC_READ_U8(DATA)
Read an 8-bit unsigned value from EtherCAT data.
Definition: ecrt.h:2127
ecrt_master_write_idn
int ecrt_master_write_idn(ec_master_t *master, uint16_t slave_position, uint8_t drive_no, uint16_t idn, uint8_t *data, size_t data_size, uint16_t *error_code)
Executes an SoE write request.
Definition: master.c:3117
ec_slave_config
EtherCAT slave configuration.
Definition: slave_config.h:118
ec_datagram_t::queue
struct list_head queue
Master datagram queue item.
Definition: datagram.h:88
ec_slave_info_t::product_code
uint32_t product_code
Product-Code stored on the slave.
Definition: ecrt.h:371
device.h
EtherCAT device structure.
ec_master::app_receive_cb
void(* app_receive_cb)(void *)
Application&#39;s receive datagrams callback.
Definition: master.h:302
ec_soe_request_write
void ec_soe_request_write(ec_soe_request_t *req)
Request a write operation.
Definition: soe_request.c:245
ec_device::dev
struct net_device * dev
pointer to the assigned net_device
Definition: device.h:84
ec_fsm_master_exec
int ec_fsm_master_exec(ec_fsm_master_t *fsm)
Executes the current state of the state machine.
Definition: fsm_master.c:150
ec_soe_request_init
void ec_soe_request_init(ec_soe_request_t *req)
SoE request constructor.
Definition: soe_request.c:56
slave_config.h
EtherCAT slave configuration structure.
ecrt_master_slave_config_err
ec_slave_config_t * ecrt_master_slave_config_err(ec_master_t *master, uint16_t alias, uint16_t position, uint32_t vendor_id, uint32_t product_code)
Same as ecrt_master_slave_config(), but with ERR_PTR() return value.
Definition: master.c:2564
ec_device_poll
void ec_device_poll(ec_device_t *device)
Calls the poll function of the assigned net_device.
Definition: device.c:478
ec_eoe_clear
void ec_eoe_clear(ec_eoe_t *eoe)
EoE destructor.
Definition: ethernet.c:214
ecrt_master_reference_clock_time
int ecrt_master_reference_clock_time(ec_master_t *master, uint32_t *time)
Get the lower 32 bit of the reference clock system time.
Definition: master.c:2793
ec_master_info_t
Master information.
Definition: ecrt.h:332
ec_master::index
unsigned int index
Index.
Definition: master.h:195
ec_master_config_count
unsigned int ec_master_config_count(const ec_master_t *master)
Get the number of slave configurations provided by the application.
Definition: master.c:1866
EC_DATAGRAM_ERROR
Error while sending/receiving (dequeued).
Definition: datagram.h:80
EC_DATAGRAM_APWR
Auto Increment Physical Write.
Definition: datagram.h:53
ec_datagram_t::address
uint8_t address[EC_ADDR_LEN]
Recipient address.
Definition: datagram.h:93
ec_device_stats_t::last_tx_bytes
u64 last_tx_bytes
Number of bytes sent of last statistics cycle.
Definition: master.h:162
ec_sdo_request_alloc
int ec_sdo_request_alloc(ec_sdo_request_t *req, size_t size)
Pre-allocates the data memory.
Definition: sdo_request.c:127
ec_sii_t::product_code
uint32_t product_code
Vendor-specific product code.
Definition: slave.h:136
ec_domain_init
void ec_domain_init(ec_domain_t *domain, ec_master_t *master, unsigned int index)
Domain constructor.
Definition: domain.c:58
EC_SLAVE_STATE_PREOP
PREOP state (mailbox communication, no IO)
Definition: globals.h:132
ec_slave_config_clear
void ec_slave_config_clear(ec_slave_config_t *sc)
Slave configuration destructor.
Definition: slave_config.c:102
EC_DEVICE_BACKUP
Backup device.
Definition: globals.h:203
EC_DATAGRAM_RECEIVED
Received (dequeued).
Definition: datagram.h:78
ec_eoe
Ethernet over EtherCAT (EoE) handler.
Definition: ethernet.h:76
ec_master::fsm
ec_fsm_master_t fsm
Master state machine.
Definition: master.h:221
ec_master::cdev
ec_cdev_t cdev
Master character device.
Definition: master.h:198
ec_device_stats_t::rx_bytes
u64 rx_bytes
Number of bytes received.
Definition: master.h:163
EC_DATAGRAM_FOOTER_SIZE
#define EC_DATAGRAM_FOOTER_SIZE
Size of an EtherCAT datagram footer.
Definition: globals.h:85
ec_master_link_state_t::al_states
unsigned int al_states
Application-layer states of the slaves on the given link.
Definition: ecrt.h:289
EC_MASTER_INFO
#define EC_MASTER_INFO(master, fmt, args...)
Convenience macro for printing master-specific information to syslog.
Definition: master.h:73
ec_slave::error_flag
unsigned int error_flag
Stop processing after an error.
Definition: slave.h:193
ec_slave_info_t::position
uint16_t position
Offset of the slave in the ring.
Definition: ecrt.h:369
ec_slave_info_t::receive_time
uint32_t receive_time
Receive time on DC transmission delay measurement.
Definition: ecrt.h:379
ec_master::config_changed
unsigned int config_changed
The configuration changed.
Definition: master.h:225
ec_master
EtherCAT master.
Definition: master.h:194
ec_master::injection_seq_rt
unsigned int injection_seq_rt
Datagram injection sequence number for the realtime side.
Definition: master.h:228
ec_master_receive_datagrams
void ec_master_receive_datagrams(ec_master_t *master, ec_device_t *device, const uint8_t *frame_data, size_t size)
Processes a received frame.
Definition: master.c:1125
EC_DATAGRAM_FPWR
Configured Address Physical Write.
Definition: datagram.h:56
FORCE_OUTPUT_CORRUPTED
#define FORCE_OUTPUT_CORRUPTED
Always output corrupted frames.
Definition: master.c:70
ec_datagram_t::index
uint8_t index
Index (set by master).
Definition: datagram.h:98
ecrt_master_sync_reference_clock
void ecrt_master_sync_reference_clock(ec_master_t *master)
Queues the DC reference clock drift compensation datagram for sending.
Definition: master.c:2812
ec_slave_port_link_t::link_up
uint8_t link_up
Link detected.
Definition: ecrt.h:355
ec_master::devices
ec_device_t devices[EC_MAX_NUM_DEVICES]
EtherCAT devices.
Definition: master.h:211
ec_slave_config_load_default_sync_config
void ec_slave_config_load_default_sync_config(ec_slave_config_t *sc)
Loads the default PDO assignment from the slave object.
Definition: slave_config.c:291
ec_master::config_busy
unsigned int config_busy
State of slave configuration.
Definition: master.h:257
ecrt_sdo_request_write
void ecrt_sdo_request_write(ec_sdo_request_t *req)
Schedule an SDO write operation.
Definition: sdo_request.c:235
ec_master_inject_external_datagrams
void ec_master_inject_external_datagrams(ec_master_t *master)
Injects external datagrams that fit into the datagram queue.
Definition: master.c:790
ec_fsm_master_clear
void ec_fsm_master_clear(ec_fsm_master_t *fsm)
Destructor.
Definition: fsm_master.c:103
ec_eoe_is_open
int ec_eoe_is_open(const ec_eoe_t *eoe)
Returns the state of the device.
Definition: ethernet.c:372
ec_device_clear_stats
void ec_device_clear_stats(ec_device_t *device)
Clears the frame statistics.
Definition: device.c:374
ec_sii_t::name
char * name
Slave name.
Definition: slave.h:158
ec_master_set_send_interval
void ec_master_set_send_interval(ec_master_t *master, unsigned int send_interval)
Sets the expected interval between calls to ecrt_master_send and calculates the maximum amount of dat...
Definition: master.c:904
ec_datagram_t::jiffies_received
unsigned long jiffies_received
Jiffies, when the datagram was received.
Definition: datagram.h:108
ec_domain
EtherCAT domain.
Definition: domain.h:54
ec_master_eoe_stop
void ec_master_eoe_stop(ec_master_t *master)
Stops the Ethernet over EtherCAT processing.
Definition: master.c:1715
ec_master::send_cb
void(* send_cb)(void *)
Current send datagrams callback.
Definition: master.h:297
ec_sii_t::vendor_id
uint32_t vendor_id
Vendor ID.
Definition: slave.h:135
ec_sdo_request::complete_access
uint8_t complete_access
SDO shall be transferred completely.
Definition: sdo_request.h:55
ec_slave_port_t::delay_to_next_dc
uint32_t delay_to_next_dc
Delay to next slave with DC support behind this port [ns].
Definition: slave.h:124
ec_master::thread
struct task_struct * thread
Master thread.
Definition: master.h:288
ec_eoe::queue_datagram
unsigned int queue_datagram
the datagram is ready for queuing
Definition: ethernet.h:81
ecrt_sdo_request_index
void ecrt_sdo_request_index(ec_sdo_request_t *req, uint16_t index, uint8_t subindex)
Set the SDO index and subindex.
Definition: sdo_request.c:187
ec_master::dc_ref_clock
ec_slave_t * dc_ref_clock
DC reference clock slave.
Definition: master.h:248
ec_cdev_init
int ec_cdev_init(ec_cdev_t *cdev, ec_master_t *master, dev_t dev_num)
Constructor.
Definition: cdev.c:116
ec_slave::force_config
unsigned int force_config
Force (re-)configuration.
Definition: slave.h:194
EC_SDO_INJECTION_TIMEOUT
#define EC_SDO_INJECTION_TIMEOUT
SDO injection timeout in microseconds.
Definition: globals.h:50
ecrt_master_receive
void ecrt_master_receive(ec_master_t *master)
Fetches received frames from the hardware and processes the datagrams.
Definition: master.c:2495
EC_MAX_DATA_SIZE
#define EC_MAX_DATA_SIZE
Resulting maximum data size of a single datagram in a frame.
Definition: globals.h:91
ec_soe_request_t
Sercos-over-EtherCAT request.
Definition: soe_request.h:48
ec_master_init_static
void ec_master_init_static(void)
Static variables initializer.
Definition: master.c:117
ec_datagram_clear
void ec_datagram_clear(ec_datagram_t *datagram)
Destructor.
Definition: datagram.c:118
ecrt_master_send
void ecrt_master_send(ec_master_t *master)
Sends all datagrams in the queue.
Definition: master.c:2451