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