48 #include "globals.h"

    48 #include "globals.h"

    49 #include "master.h"

    49 #include "master.h"

    50 #include "slave.h"

    50 #include "slave.h"

    51 #include "device.h"

    51 #include "device.h"

    52 #include "datagram.h"

    52 #include "datagram.h"

    53 #include "ethernet.h"

    54 #include "ethernet.h"

    54 

    56 

    55 /*****************************************************************************/

    57 /*****************************************************************************/

    56 

    58 

    57 void ec_master_destroy_domains(ec_master_t *);

    59 void ec_master_destroy_domains(ec_master_t *);

    58 void ec_master_sync_io(ec_master_t *);

    60 void ec_master_sync_io(ec_master_t *);

    59 static int ec_master_idle_thread(ec_master_t *);

    61 static int ec_master_idle_thread(ec_master_t *);

    60 static int ec_master_operation_thread(ec_master_t *);

    62 static int ec_master_operation_thread(ec_master_t *);

    61 void ec_master_eoe_run(unsigned long);

    64 void ec_master_eoe_run(unsigned long);

    62 void ec_master_check_sdo(unsigned long);

    66 void ec_master_check_sdo(unsigned long);

    63 int ec_master_measure_bus_time(ec_master_t *);

    67 int ec_master_measure_bus_time(ec_master_t *);

    64 ssize_t ec_show_master_attribute(struct kobject *, struct attribute *, char *);

    68 ssize_t ec_show_master_attribute(struct kobject *, struct attribute *, char *);

    65 ssize_t ec_store_master_attribute(struct kobject *, struct attribute *,

    69 ssize_t ec_store_master_attribute(struct kobject *, struct attribute *,

    66                                   const char *, size_t);

    70                                   const char *, size_t);

   143     master->stats.unmatched = 0;

   147     master->stats.unmatched = 0;

   144     master->stats.output_jiffies = 0;

   148     master->stats.output_jiffies = 0;

   145 

   149 

   146     for (i = 0; i < HZ; i++) {

   150     for (i = 0; i < HZ; i++) {

   147         master->idle_cycle_times[i] = 0;

   151         master->idle_cycle_times[i] = 0;

   148         master->eoe_cycle_times[i] = 0;

   153         master->eoe_cycle_times[i] = 0;

   149     }

   155     }

   150     master->idle_cycle_time_pos = 0;

   156     master->idle_cycle_time_pos = 0;

   151     master->eoe_cycle_time_pos = 0;

   158     master->eoe_cycle_time_pos = 0;

   152 

   159 

   153     init_timer(&master->eoe_timer);

   160     init_timer(&master->eoe_timer);

   154     master->eoe_timer.function = ec_master_eoe_run;

   161     master->eoe_timer.function = ec_master_eoe_run;

   155     master->eoe_timer.data = (unsigned long) master;

   162     master->eoe_timer.data = (unsigned long) master;

   156     master->eoe_running = 0;

   163     master->eoe_running = 0;

   157     INIT_LIST_HEAD(&master->eoe_handlers);

   164     INIT_LIST_HEAD(&master->eoe_handlers);

   158 

   166 

   159     master->internal_lock = SPIN_LOCK_UNLOCKED;

   167     master->internal_lock = SPIN_LOCK_UNLOCKED;

   160     master->request_cb = NULL;

   168     master->request_cb = NULL;

   161     master->release_cb = NULL;

   169     master->release_cb = NULL;

   162     master->cb_data = NULL;

   170     master->cb_data = NULL;

   226 

   234 

   227 void ec_master_clear(

   235 void ec_master_clear(

   228         ec_master_t *master /**< EtherCAT master */

   236         ec_master_t *master /**< EtherCAT master */

   229         )

   237         )

   230 {

   238 {

   231     ec_master_clear_eoe_handlers(master);

   240     ec_master_clear_eoe_handlers(master);

   232     ec_master_destroy_slaves(master);

   242     ec_master_destroy_slaves(master);

   233     ec_master_destroy_domains(master);

   243     ec_master_destroy_domains(master);

   234     ec_fsm_master_clear(&master->fsm);

   244     ec_fsm_master_clear(&master->fsm);

   235     ec_datagram_clear(&master->fsm_datagram);

   245     ec_datagram_clear(&master->fsm_datagram);

   236     ec_device_clear(&master->backup_device);

   246     ec_device_clear(&master->backup_device);

   241     kobject_put(&master->kobj);

   251     kobject_put(&master->kobj);

   242 }

   252 }

   243 

   253 

   244 /*****************************************************************************/

   254 /*****************************************************************************/

   245 

   255 

   246 /**

   257 /**

   247  * Clear and free all EoE handlers.

   258  * Clear and free all EoE handlers.

   248  */

   259  */

   249 

   260 

   250 void ec_master_clear_eoe_handlers(

   261 void ec_master_clear_eoe_handlers(

   257         list_del(&eoe->list);

   268         list_del(&eoe->list);

   258         ec_eoe_clear(eoe);

   269         ec_eoe_clear(eoe);

   259         kfree(eoe);

   270         kfree(eoe);

   260     }

   271     }

   261 }

   272 }

   262 

   274 

   263 /*****************************************************************************/

   275 /*****************************************************************************/

   264 

   276 

   265 /**

   277 /**

   266    Destroy all slaves.

   278    Destroy all slaves.

   392 

   404 

   393 void ec_master_leave_idle_mode(ec_master_t *master /**< EtherCAT master */)

   405 void ec_master_leave_idle_mode(ec_master_t *master /**< EtherCAT master */)

   394 {

   406 {

   395     master->mode = EC_MASTER_MODE_ORPHANED;

   407     master->mode = EC_MASTER_MODE_ORPHANED;

   396     

   408     

   397     ec_master_eoe_stop(master);

   410     ec_master_eoe_stop(master);

   398     ec_master_thread_stop(master);

   412     ec_master_thread_stop(master);

   399     ec_master_destroy_slaves(master);

   413     ec_master_destroy_slaves(master);

   400 }

   414 }

   401 

   415 

   402 /*****************************************************************************/

   416 /*****************************************************************************/

   406  */

   420  */

   407 

   421 

   408 int ec_master_enter_operation_mode(ec_master_t *master /**< EtherCAT master */)

   422 int ec_master_enter_operation_mode(ec_master_t *master /**< EtherCAT master */)

   409 {

   423 {

   410     ec_slave_t *slave;

   424     ec_slave_t *slave;

   411     ec_eoe_t *eoe;

   426     ec_eoe_t *eoe;

   412 

   428 

   413     down(&master->config_sem);

   429     down(&master->config_sem);

   414     master->allow_config = 0; // temporarily disable slave configuration

   430     master->allow_config = 0; // temporarily disable slave configuration

   415     up(&master->config_sem);

   431     up(&master->config_sem);

   416 

   432 

   440 

   456 

   441     // set states for all slaves

   457     // set states for all slaves

   442     list_for_each_entry(slave, &master->slaves, list) {

   458     list_for_each_entry(slave, &master->slaves, list) {

   443         ec_slave_request_state(slave, EC_SLAVE_STATE_PREOP);

   459         ec_slave_request_state(slave, EC_SLAVE_STATE_PREOP);

   444     }

   460     }

   445     // ... but set EoE slaves to OP

   462     // ... but set EoE slaves to OP

   446     list_for_each_entry(eoe, &master->eoe_handlers, list) {

   463     list_for_each_entry(eoe, &master->eoe_handlers, list) {

   447         if (ec_eoe_is_open(eoe))

   464         if (ec_eoe_is_open(eoe))

   448             ec_slave_request_state(eoe->slave, EC_SLAVE_STATE_OP);

   465             ec_slave_request_state(eoe->slave, EC_SLAVE_STATE_OP);

   449     }

   466     }

   450 

   468 

   451     if (master->debug_level)

   469     if (master->debug_level)

   452         EC_DBG("Switching to operation mode.\n");

   470         EC_DBG("Switching to operation mode.\n");

   453 

   471 

   454     master->mode = EC_MASTER_MODE_OPERATION;

   472     master->mode = EC_MASTER_MODE_OPERATION;

   473 

   491 

   474 void ec_master_leave_operation_mode(ec_master_t *master

   492 void ec_master_leave_operation_mode(ec_master_t *master

   475                                     /**< EtherCAT master */)

   493                                     /**< EtherCAT master */)

   476 {

   494 {

   477     ec_slave_t *slave;

   495     ec_slave_t *slave;

   478     ec_eoe_t *eoe;

   497     ec_eoe_t *eoe;

   479 

   499 

   480     master->mode = EC_MASTER_MODE_IDLE;

   500     master->mode = EC_MASTER_MODE_IDLE;

   481 

   501 

   482     ec_master_eoe_stop(master);

   503     ec_master_eoe_stop(master);

   483     ec_master_thread_stop(master);

   505     ec_master_thread_stop(master);

   484     

   506     

   485     master->request_cb = ec_master_request_cb;

   507     master->request_cb = ec_master_request_cb;

   486     master->release_cb = ec_master_release_cb;

   508     master->release_cb = ec_master_release_cb;

   487     master->cb_data = master;

   509     master->cb_data = master;

   489     // set states for all slaves

   511     // set states for all slaves

   490     list_for_each_entry(slave, &master->slaves, list) {

   512     list_for_each_entry(slave, &master->slaves, list) {

   491         ec_slave_reset(slave);

   513         ec_slave_reset(slave);

   492         ec_slave_request_state(slave, EC_SLAVE_STATE_PREOP);

   514         ec_slave_request_state(slave, EC_SLAVE_STATE_PREOP);

   493     }

   515     }

   494     // ... but leave EoE slaves in OP

   517     // ... but leave EoE slaves in OP

   495     list_for_each_entry(eoe, &master->eoe_handlers, list) {

   518     list_for_each_entry(eoe, &master->eoe_handlers, list) {

   496         if (ec_eoe_is_open(eoe))

   519         if (ec_eoe_is_open(eoe))

   497             ec_slave_request_state(eoe->slave, EC_SLAVE_STATE_OP);

   520             ec_slave_request_state(eoe->slave, EC_SLAVE_STATE_OP);

   498     }

   521     }

   499 

   523 

   500     ec_master_destroy_domains(master);

   524     ec_master_destroy_domains(master);

   501     

   525     

   502     if (ec_master_thread_start(master, ec_master_idle_thread))

   526     if (ec_master_thread_start(master, ec_master_idle_thread))

   503         EC_WARN("Failed to restart master thread!\n");

   527         EC_WARN("Failed to restart master thread!\n");

   504     ec_master_eoe_start(master);

   529     ec_master_eoe_start(master);

   505 

   531 

   506     master->allow_scan = 1;

   532     master->allow_scan = 1;

   507     master->allow_config = 1;

   533     master->allow_config = 1;

   508 }

   534 }

   509 

   535 

   939 ssize_t ec_master_info(ec_master_t *master, /**< EtherCAT master */

   965 ssize_t ec_master_info(ec_master_t *master, /**< EtherCAT master */

   940                        char *buffer /**< memory to store data */

   966                        char *buffer /**< memory to store data */

   941                        )

   967                        )

   942 {

   968 {

   943     off_t off = 0;

   969     off_t off = 0;

   944     ec_eoe_t *eoe;

   971     ec_eoe_t *eoe;

   945     uint32_t cur, sum, min, max, pos, i;

   973     uint32_t cur, sum, min, max, pos, i;

   946 

   974 

   947     off += sprintf(buffer + off, "\nMode: ");

   975     off += sprintf(buffer + off, "\nMode: ");

   948     switch (master->mode) {

   976     switch (master->mode) {

   949         case EC_MASTER_MODE_ORPHANED:

   977         case EC_MASTER_MODE_ORPHANED:

   988         if (cur > max) max = cur;

  1016         if (cur > max) max = cur;

   989     }

  1017     }

   990     off += sprintf(buffer + off, "  Idle cycle: %u / %u.%u / %u\n",

  1018     off += sprintf(buffer + off, "  Idle cycle: %u / %u.%u / %u\n",

   991                    min, sum / HZ, (sum * 100 / HZ) % 100, max);

  1019                    min, sum / HZ, (sum * 100 / HZ) % 100, max);

   992 

  1020 

   993     sum = 0;

  1022     sum = 0;

   994     min = 0xFFFFFFFF;

  1023     min = 0xFFFFFFFF;

   995     max = 0;

  1024     max = 0;

   996     pos = master->eoe_cycle_time_pos;

  1025     pos = master->eoe_cycle_time_pos;

   997     for (i = 0; i < HZ; i++) {

  1026     for (i = 0; i < HZ; i++) {

  1008     list_for_each_entry(eoe, &master->eoe_handlers, list) {

  1037     list_for_each_entry(eoe, &master->eoe_handlers, list) {

  1009         off += sprintf(buffer + off, "  %s: %u / %u (%u KB/s)\n",

  1038         off += sprintf(buffer + off, "  %s: %u / %u (%u KB/s)\n",

  1010                        eoe->dev->name, eoe->rx_rate, eoe->tx_rate,

  1039                        eoe->dev->name, eoe->rx_rate, eoe->tx_rate,

  1011                        ((eoe->rx_rate + eoe->tx_rate) / 8 + 512) / 1024);

  1040                        ((eoe->rx_rate + eoe->tx_rate) / 8 + 512) / 1024);

  1012     }

  1041     }

  1013 

  1043 

  1014     off += sprintf(buffer + off, "\n");

  1044     off += sprintf(buffer + off, "\n");

  1015 

  1045 

  1016     return off;

  1046     return off;

  1017 }

  1047 }

  1077     return -EINVAL;

  1107     return -EINVAL;

  1078 }

  1108 }

  1079 

  1109 

  1080 /*****************************************************************************/

  1110 /*****************************************************************************/

  1081 

  1111 

  1082 /**

  1113 /**

  1083    Starts Ethernet-over-EtherCAT processing on demand.

  1114    Starts Ethernet-over-EtherCAT processing on demand.

  1084 */

  1115 */

  1085 

  1116 

  1086 void ec_master_eoe_start(ec_master_t *master /**< EtherCAT master */)

  1117 void ec_master_eoe_start(ec_master_t *master /**< EtherCAT master */)

  1134     ec_eoe_t *eoe;

  1165     ec_eoe_t *eoe;

  1135     unsigned int none_open = 1;

  1166     unsigned int none_open = 1;

  1136     cycles_t cycles_start, cycles_end;

  1167     cycles_t cycles_start, cycles_end;

  1137     unsigned long restart_jiffies;

  1168     unsigned long restart_jiffies;

  1138 

  1169 

  1139     list_for_each_entry(eoe, &master->eoe_handlers, list) {

  1171     list_for_each_entry(eoe, &master->eoe_handlers, list) {

  1140         if (ec_eoe_is_open(eoe)) {

  1172         if (ec_eoe_is_open(eoe)) {

  1141             none_open = 0;

  1173             none_open = 0;

  1142             break;

  1174             break;

  1143         }

  1175         }

  1171     restart_jiffies = HZ / EC_EOE_FREQUENCY;

  1203     restart_jiffies = HZ / EC_EOE_FREQUENCY;

  1172     if (!restart_jiffies) restart_jiffies = 1;

  1204     if (!restart_jiffies) restart_jiffies = 1;

  1173     master->eoe_timer.expires += restart_jiffies;

  1205     master->eoe_timer.expires += restart_jiffies;

  1174     add_timer(&master->eoe_timer);

  1206     add_timer(&master->eoe_timer);

  1175 }

  1207 }

  1176 

  1209 

  1177 /*****************************************************************************/

  1210 /*****************************************************************************/

  1178 

  1211 

  1179 /**

  1212 /**

  1180    Measures the time, a frame is on the bus.

  1213    Measures the time, a frame is on the bus.

  1433         EC_ERR("Failed to configure slaves.\n");

  1466         EC_ERR("Failed to configure slaves.\n");

  1434         return -1;

  1467         return -1;

  1435     }

  1468     }

  1436     

  1469     

  1437     // restart EoE process and master thread with new locking

  1470     // restart EoE process and master thread with new locking

  1438     ec_master_eoe_stop(master);

  1472     ec_master_eoe_stop(master);

  1439     ec_master_thread_stop(master);

  1474     ec_master_thread_stop(master);

  1440 

  1475 

  1441     ec_master_prepare(master); // prepare asynchronous IO

  1476     ec_master_prepare(master); // prepare asynchronous IO

  1442 

  1477 

  1443     if (master->debug_level)

  1478     if (master->debug_level)

  1451     

  1486     

  1452     if (ec_master_thread_start(master, ec_master_operation_thread)) {

  1487     if (ec_master_thread_start(master, ec_master_operation_thread)) {

  1453         EC_ERR("Failed to start master thread!\n");

  1488         EC_ERR("Failed to start master thread!\n");

  1454         return -1;

  1489         return -1;

  1455     }

  1490     }

  1456     ec_master_eoe_start(master);

  1492     ec_master_eoe_start(master);

  1457     return 0;

  1494     return 0;

  1458 }

  1495 }

  1459 

  1496 

  1460 /*****************************************************************************/

  1497 /*****************************************************************************/

  1461 

  1498