58 {

    58 {

    59     domain->master = master;

    59     domain->master = master;

    60     domain->index = index;

    60     domain->index = index;

    61     INIT_LIST_HEAD(&domain->fmmu_configs);

    61     INIT_LIST_HEAD(&domain->fmmu_configs);

    62     domain->data_size = 0;

    62     domain->data_size = 0;

    63     domain->data = NULL;

    64     domain->data = NULL;

    64     domain->data_origin = EC_ORIG_INTERNAL;

    65     domain->data_origin = EC_ORIG_INTERNAL;

    65     domain->logical_base_address = 0x00000000;

    66     domain->logical_base_address = 0x00000000;

    66     INIT_LIST_HEAD(&domain->datagrams);

    67     INIT_LIST_HEAD(&domain->datagrams);

    67     domain->working_counter = 0x0000;

    68     domain->working_counter = 0x0000;

   111         )

   112         )

   112 {

   113 {

   113     fmmu->domain = domain;

   114     fmmu->domain = domain;

   114 

   115 

   115     domain->data_size += fmmu->data_size;

   116     domain->data_size += fmmu->data_size;

   116     list_add_tail(&fmmu->list, &domain->fmmu_configs);

   118     list_add_tail(&fmmu->list, &domain->fmmu_configs);

   117 

   119 

   118     if (domain->master->debug_level)

   120     if (domain->master->debug_level)

   119         EC_DBG("Domain %u: Added %u bytes, total %zu.\n", domain->index,

   121         EC_DBG("Domain %u: Added %u bytes, total %zu.\n", domain->index,

   120                 fmmu->data_size, domain->data_size);

   122                 fmmu->data_size, domain->data_size);

   176         domain->expected_working_counter += used[EC_DIR_INPUT];

   178         domain->expected_working_counter += used[EC_DIR_INPUT];

   177     }

   179     }

   178 

   180 

   179     ec_datagram_zero(datagram);

   181     ec_datagram_zero(datagram);

   180     list_add_tail(&datagram->list, &domain->datagrams);

   182     list_add_tail(&datagram->list, &domain->datagrams);

   181     return 0;

   184     return 0;

   182 }

   185 }

   183 

   186 

   184 /*****************************************************************************/

   187 /*****************************************************************************/

   185 

   188 

   234     }

   237     }

   235 

   238 

   236     list_for_each_entry(fmmu, &domain->fmmu_configs, list) {

   239     list_for_each_entry(fmmu, &domain->fmmu_configs, list) {

   237         // Correct logical FMMU address

   240         // Correct logical FMMU address

   238         fmmu->logical_start_address += base_address;

   241         fmmu->logical_start_address += base_address;

   239 

   243 

   240         // Increment Input/Output counter to determine datagram types

   244         // Increment Input/Output counter to determine datagram types

   241         // and calculate expected working counters

   245         // and calculate expected working counters

   242         if (fmmu->sc->used_for_fmmu_datagram[fmmu->dir] == 0) {

   246         if (fmmu->sc->used_for_fmmu_datagram[fmmu->dir] == 0) {

   243             ec_slave_config_t *sc = (ec_slave_config_t *)fmmu->sc;

   247             ec_slave_config_t *sc = (ec_slave_config_t *)fmmu->sc;

   245             sc->used_for_fmmu_datagram[fmmu->dir] = 1;

   249             sc->used_for_fmmu_datagram[fmmu->dir] = 1;

   246         }

   250         }

   247 

   251 

   248         // If the current FMMU's data do not fit in the current datagram,

   252         // If the current FMMU's data do not fit in the current datagram,

   249         // allocate a new one.

   253         // allocate a new one.

   251             ret = ec_domain_add_datagram(domain,

   255             ret = ec_domain_add_datagram(domain,

   252                     domain->logical_base_address + datagram_offset,

   256                     domain->logical_base_address + datagram_offset,

   253                     datagram_size, domain->data + datagram_offset,

   257                     datagram_size, domain->data + datagram_offset,

   254                     datagram_used);

   258                     datagram_used);

   255             if (ret < 0)

   259             if (ret < 0)

   263                 ec_slave_config_t *sc = (ec_slave_config_t *)fmmu_temp->sc;

   267                 ec_slave_config_t *sc = (ec_slave_config_t *)fmmu_temp->sc;

   264                sc->used_for_fmmu_datagram[fmmu_temp->dir] = 0;

   268                sc->used_for_fmmu_datagram[fmmu_temp->dir] = 0;

   265             }

   269             }

   266         }

   270         }

   267 

   271 

   269     }

   273     }

   270 

   274 

   271     // Allocate last datagram, if data are left (this is also the case if the

   275     // Allocate last datagram, if data are left (this is also the case if the

   272     // process data fit into a single datagram)

   276     // process data fit into a single datagram)

   273     if (datagram_size) {

   277     if (datagram_size) {