Mercurial Mercurial > etherlabmaster / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
master/domain.c
branchstable-1.5
changeset 2470 4f97d61a8671
parent 2468 3134b7255f3d
child 2522 ec403cf308eb
equal deleted inserted replaced
2469:634ba3b1eb95 2470:4f97d61a8671 
   449 
   449 
   450 /*****************************************************************************/
 
   450 /*****************************************************************************/
 
   451 
   451 
   452 void ecrt_domain_process(ec_domain_t *domain)
 
   452 void ecrt_domain_process(ec_domain_t *domain)
 
   453 {
 
   453 {
 
   454     uint16_t wc_sum[EC_MAX_NUM_DEVICES] = {}, redundant_wc, wc_total;
 
   454     uint16_t wc_sum[EC_MAX_NUM_DEVICES] = {}, wc_total;
 
       
   455     ec_datagram_pair_t *pair;
 
       
   456 #if EC_MAX_NUM_DEVICES > 1
 
       
   457     uint16_t datagram_pair_wc, redundant_wc;
 
       
   458     unsigned int datagram_offset;
 
       
   459     ec_fmmu_config_t *fmmu = list_first_entry(&domain->fmmu_configs,
 
       
   460             ec_fmmu_config_t, list);
 
       
   461     unsigned int redundancy;
 
       
   462 #endif
 
   455     unsigned int dev_idx, wc_change;
 
   463     unsigned int dev_idx, wc_change;
 
   456     unsigned int redundancy;
 
       
   457 
   464 
   458 #if DEBUG_REDUNDANCY
 
   465 #if DEBUG_REDUNDANCY
 
   459     EC_MASTER_DBG(domain->master, 1, "domain %u process\n", domain->index);
 
   466     EC_MASTER_DBG(domain->master, 1, "domain %u process\n", domain->index);
 
   460 #endif
 
   467 #endif
 
   461 
   468 
       
   469     list_for_each_entry(pair, &domain->datagram_pairs, list) {
 
   462 #if EC_MAX_NUM_DEVICES > 1
 
   470 #if EC_MAX_NUM_DEVICES > 1
 
   463     if (ec_master_num_devices(domain->master) > 1) {
 
   471         datagram_pair_wc = ec_datagram_pair_process(pair, wc_sum);
 
   464         ec_datagram_pair_t *pair;
 
   472 #else
 
   465         ec_fmmu_config_t *fmmu =
 
   473         ec_datagram_pair_process(pair, wc_sum);
 
   466             list_first_entry(&domain->fmmu_configs, ec_fmmu_config_t, list);
 
   474 #endif
 
   467 
   475 
   468         list_for_each_entry(pair, &domain->datagram_pairs, list) {
 
   476 #if EC_MAX_NUM_DEVICES > 1
 
       
   477         if (ec_master_num_devices(domain->master) > 1) {
 
   469             ec_datagram_t *main_datagram = &pair->datagrams[EC_DEVICE_MAIN];
 
   478             ec_datagram_t *main_datagram = &pair->datagrams[EC_DEVICE_MAIN];
 
   470             uint32_t logical_datagram_address =
 
   479             uint32_t logical_datagram_address =
 
   471                 EC_READ_U32(main_datagram->address);
 
   480                 EC_READ_U32(main_datagram->address);
 
   472             size_t datagram_size = main_datagram->data_size;
 
   481             size_t datagram_size = main_datagram->data_size;
 
   473             uint16_t datagram_pair_wc;
 
       
   474 
   482 
   475 #if DEBUG_REDUNDANCY
 
   483 #if DEBUG_REDUNDANCY
 
   476             EC_MASTER_DBG(domain->master, 1, "dgram %s log=%u\n",
 
   484             EC_MASTER_DBG(domain->master, 1, "dgram %s log=%u\n",
 
   477                     main_datagram->name, logical_datagram_address);
 
   485                     main_datagram->name, logical_datagram_address);
 
   478 #endif
 
   486 #endif
 
   479 
   487 
   480             /* Redundancy: Go through FMMU configs to detect data changes. */
 
   488             /* Redundancy: Go through FMMU configs to detect data changes. */
 
   481             list_for_each_entry_from(fmmu, &domain->fmmu_configs, list) {
 
   489             list_for_each_entry_from(fmmu, &domain->fmmu_configs, list) {
 
   482                 unsigned int datagram_offset;
 
       
   483                 ec_datagram_t *backup_datagram =
 
   490                 ec_datagram_t *backup_datagram =
 
   484                     &pair->datagrams[EC_DEVICE_BACKUP];
 
   491                     &pair->datagrams[EC_DEVICE_BACKUP];
 
   485 
   492 
   486                 if (fmmu->dir != EC_DIR_INPUT) {
 
   493                 if (fmmu->dir != EC_DIR_INPUT) {
 
   487                     continue;
 
   494                     continue;
 
   508                             fmmu->data_size);
 
   515                             fmmu->data_size);
 
   509                     ec_print_data(backup_datagram->data + datagram_offset,
 
   516                     ec_print_data(backup_datagram->data + datagram_offset,
 
   510                             fmmu->data_size);
 
   517                             fmmu->data_size);
 
   511                 }
 
   518                 }
 
   512 #endif
 
   519 #endif
 
   513                 datagram_pair_wc = ec_datagram_pair_process(pair, wc_sum);
 
       
   514 
   520 
   515                 if (data_changed(pair->send_buffer, main_datagram,
 
   521                 if (data_changed(pair->send_buffer, main_datagram,
 
   516                             datagram_offset, fmmu->data_size)) {
 
   522                             datagram_offset, fmmu->data_size)) {
 
   517                     /* data changed on main link: no copying necessary. */
 
   523                     /* data changed on main link: no copying necessary. */
 
   518 #if DEBUG_REDUNDANCY
 
   524 #if DEBUG_REDUNDANCY
 
   543                             "no change and incomplete\n");
 
   549                             "no change and incomplete\n");
 
   544 #endif
 
   550 #endif
 
   545                 }
 
   551                 }
 
   546             }
 
   552             }
 
   547         }
 
   553         }
 
   548     }
 
       
   549 #endif // EC_MAX_NUM_DEVICES > 1
 
   554 #endif // EC_MAX_NUM_DEVICES > 1
 
   550 
   555     }
 
       
   556 
       
   557 #if EC_MAX_NUM_DEVICES > 1
 
   551     redundant_wc = 0;
 
   558     redundant_wc = 0;
 
   552     for (dev_idx = EC_DEVICE_BACKUP;
 
   559     for (dev_idx = EC_DEVICE_BACKUP;
 
   553             dev_idx < ec_master_num_devices(domain->master); dev_idx++) {
 
   560             dev_idx < ec_master_num_devices(domain->master); dev_idx++) {
 
   554         redundant_wc += wc_sum[dev_idx];
 
   561         redundant_wc += wc_sum[dev_idx];
 
   555     }
 
   562     }
 
   565                     "Domain %u: Redundant link unused again.\n",
 
   572                     "Domain %u: Redundant link unused again.\n",
 
   566                     domain->index);
 
   573                     domain->index);
 
   567         }
 
   574         }
 
   568         domain->redundancy_active = redundancy;
 
   575         domain->redundancy_active = redundancy;
 
   569     }
 
   576     }
 
       
   577 #else
 
       
   578     domain->redundancy_active = 0;
 
       
   579 #endif
 
   570 
   580 
   571     wc_change = 0;
 
   581     wc_change = 0;
 
   572     wc_total = 0;
 
   582     wc_total = 0;
 
   573     for (dev_idx = EC_DEVICE_MAIN;
 
   583     for (dev_idx = EC_DEVICE_MAIN;
 
   574             dev_idx < ec_master_num_devices(domain->master); dev_idx++) {
 
   584             dev_idx < ec_master_num_devices(domain->master); dev_idx++) {
 
   594             EC_MASTER_INFO(domain->master, "Domain %u: %u working counter"
 
   604             EC_MASTER_INFO(domain->master, "Domain %u: %u working counter"
 
   595                     " changes - now %u/%u", domain->index,
 
   605                     " changes - now %u/%u", domain->index,
 
   596                     domain->working_counter_changes,
 
   606                     domain->working_counter_changes,
 
   597                     wc_total, domain->expected_working_counter);
 
   607                     wc_total, domain->expected_working_counter);
 
   598         }
 
   608         }
 
       
   609 #if EC_MAX_NUM_DEVICES > 1
 
   599         if (ec_master_num_devices(domain->master) > 1) {
 
   610         if (ec_master_num_devices(domain->master) > 1) {
 
   600             printk(" (");
 
   611             printk(" (");
 
   601             for (dev_idx = EC_DEVICE_MAIN;
 
   612             for (dev_idx = EC_DEVICE_MAIN;
 
   602                     dev_idx < ec_master_num_devices(domain->master);
 
   613                     dev_idx < ec_master_num_devices(domain->master);
 
   603                     dev_idx++) {
 
   614                     dev_idx++) {
 
   606                     printk("+");
 
   617                     printk("+");
 
   607                 }
 
   618                 }
 
   608             }
 
   619             }
 
   609             printk(")");
 
   620             printk(")");
 
   610         }
 
   621         }
 
       
   622 #endif
 
   611         printk(".\n");
 
   623         printk(".\n");
 
   612 
   624 
   613         domain->working_counter_changes = 0;
 
   625         domain->working_counter_changes = 0;
 
   614     }
 
   626     }
 
   615 }
 
   627 }
etherlabmaster