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