fp@42: /******************************************************************************
fp@42:  *
fp@54:  *  d o m a i n . c
fp@42:  *
fp@42:  *  Methoden für Gruppen von EtherCAT-Slaves.
fp@42:  *
fp@42:  *  $Id$
fp@42:  *
fp@42:  *****************************************************************************/
fp@42: 
fp@54: #include "globals.h"
fp@54: #include "domain.h"
fp@73: #include "master.h"
fp@42: 
fp@98: void ec_domain_clear_field_regs(ec_domain_t *);
fp@98: 
fp@42: /*****************************************************************************/
fp@42: 
fp@42: /**
fp@42:    Konstruktor einer EtherCAT-Domäne.
fp@73: */
fp@73: 
fp@73: void ec_domain_init(ec_domain_t *domain, /**< Domäne */
fp@73:                     ec_master_t *master, /**< Zugehöriger Master */
fp@73:                     ec_domain_mode_t mode, /**< Synchron/Asynchron */
fp@73:                     unsigned int timeout_us /**< Timeout in Mikrosekunden */
fp@73:                     )
fp@73: {
fp@73:     domain->master = master;
fp@73:     domain->mode = mode;
fp@73:     domain->timeout_us = timeout_us;
fp@73: 
fp@73:     domain->data = NULL;
fp@73:     domain->data_size = 0;
fp@98:     domain->commands = NULL;
fp@98:     domain->command_count = 0;
fp@73:     domain->base_address = 0;
fp@73:     domain->response_count = 0xFFFFFFFF;
fp@73: 
fp@73:     INIT_LIST_HEAD(&domain->field_regs);
fp@73: }
fp@73: 
fp@73: /*****************************************************************************/
fp@73: 
fp@73: /**
fp@73:    Destruktor einer EtherCAT-Domäne.
fp@73: */
fp@73: 
fp@73: void ec_domain_clear(ec_domain_t *domain /**< Domäne */)
fp@73: {
fp@98:     if (domain->data) kfree(domain->data);
fp@98:     if (domain->commands) kfree(domain->commands);
fp@98: 
fp@98:     ec_domain_clear_field_regs(domain);
fp@73: }
fp@73: 
fp@73: /*****************************************************************************/
fp@73: 
fp@73: /**
fp@73:    Registriert ein Feld in einer Domäne.
fp@73: 
fp@91:    \return 0 bei Erfolg, < 0 bei Fehler
fp@73: */
fp@73: 
fp@73: int ec_domain_reg_field(ec_domain_t *domain, /**< Domäne */
fp@73:                         ec_slave_t *slave, /**< Slave */
fp@73:                         const ec_sync_t *sync, /**< Sync-Manager */
fp@73:                         uint32_t field_offset, /**< Datenfeld-Offset */
fp@73:                         void **data_ptr /**< Adresse des Prozessdatenzeigers */
fp@73:                         )
fp@73: {
fp@73:     ec_field_reg_t *field_reg;
fp@73: 
fp@73:     if (!(field_reg = (ec_field_reg_t *) kmalloc(sizeof(ec_field_reg_t),
fp@73:                                                  GFP_KERNEL))) {
fp@84:         EC_ERR("Failed to allocate field registration.\n");
fp@73:         return -1;
fp@73:     }
fp@73: 
fp@73:     if (ec_slave_set_fmmu(slave, domain, sync)) {
fp@84:         EC_ERR("FMMU configuration failed.\n");
fp@73:         kfree(field_reg);
fp@73:         return -1;
fp@73:     }
fp@73: 
fp@73:     field_reg->slave = slave;
fp@73:     field_reg->sync = sync;
fp@73:     field_reg->field_offset = field_offset;
fp@73:     field_reg->data_ptr = data_ptr;
fp@73: 
fp@73:     list_add_tail(&field_reg->list, &domain->field_regs);
fp@73: 
fp@73:     return 0;
fp@73: }
fp@73: 
fp@73: /*****************************************************************************/
fp@73: 
fp@73: /**
fp@98:    Gibt die Liste der registrierten Datenfelder frei.
fp@98: */
fp@98: 
fp@98: void ec_domain_clear_field_regs(ec_domain_t *domain)
fp@98: {
fp@98:     ec_field_reg_t *field_reg, *next;
fp@98: 
fp@98:     list_for_each_entry_safe(field_reg, next, &domain->field_regs, list) {
fp@98:         list_del(&field_reg->list);
fp@98:         kfree(field_reg);
fp@98:     }
fp@98: }
fp@98: 
fp@98: /*****************************************************************************/
fp@98: 
fp@98: /**
fp@91:    Erzeugt eine Domäne.
fp@91: 
fp@91:    Reserviert den Speicher einer Domäne, berechnet die logischen Adressen der
fp@91:    FMMUs und setzt die Prozessdatenzeiger der registrierten Felder.
fp@91: 
fp@91:    \return 0 bei Erfolg, < 0 bei Fehler
fp@73: */
fp@73: 
fp@73: int ec_domain_alloc(ec_domain_t *domain, /**< Domäne */
fp@73:                     uint32_t base_address /**< Logische Basisadresse */
fp@73:                     )
fp@73: {
fp@98:     ec_field_reg_t *field_reg;
fp@73:     ec_slave_t *slave;
fp@73:     ec_fmmu_t *fmmu;
fp@101:     unsigned int i, j, found;
fp@101:     uint32_t data_offset;
fp@73: 
fp@73:     if (domain->data) {
fp@84:         EC_ERR("Domain already allocated!\n");
fp@73:         return -1;
fp@73:     }
fp@73: 
fp@73:     domain->base_address = base_address;
fp@73: 
fp@73:     // Größe der Prozessdaten berechnen
fp@73:     // und logische Adressen der FMMUs setzen
fp@73:     domain->data_size = 0;
fp@73:     for (i = 0; i < domain->master->slave_count; i++) {
fp@73:         slave = &domain->master->slaves[i];
fp@73:         for (j = 0; j < slave->fmmu_count; j++) {
fp@73:             fmmu = &slave->fmmus[j];
fp@73:             if (fmmu->domain == domain) {
fp@73:                 fmmu->logical_start_address = base_address + domain->data_size;
fp@73:                 domain->data_size += fmmu->sync->size;
fp@73:             }
fp@73:         }
fp@73:     }
fp@73: 
fp@73:     if (!domain->data_size) {
fp@84:         EC_WARN("Domain 0x%08X contains no data!\n", (u32) domain);
fp@98:         ec_domain_clear_field_regs(domain);
fp@98:         return 0;
fp@98:     }
fp@98: 
fp@98:     // Prozessdaten allozieren
fp@98:     if (!(domain->data = kmalloc(domain->data_size, GFP_KERNEL))) {
fp@98:         EC_ERR("Failed to allocate domain data!\n");
fp@98:         return -1;
fp@98:     }
fp@98: 
fp@98:     // Prozessdaten mit Nullen vorbelegen
fp@98:     memset(domain->data, 0x00, domain->data_size);
fp@98: 
fp@98:     // Alle Prozessdatenzeiger setzen
fp@98:     list_for_each_entry(field_reg, &domain->field_regs, list) {
fp@98:         found = 0;
fp@98:         for (i = 0; i < field_reg->slave->fmmu_count; i++) {
fp@98:             fmmu = &field_reg->slave->fmmus[i];
fp@98:             if (fmmu->domain == domain && fmmu->sync == field_reg->sync) {
fp@98:                 data_offset = fmmu->logical_start_address - base_address
fp@98:                     + field_reg->field_offset;
fp@98:                 *field_reg->data_ptr = domain->data + data_offset;
fp@98:                 found = 1;
fp@98:                 break;
fp@98:             }
fp@98:         }
fp@98: 
fp@98:         if (!found) { // Sollte nie passieren
fp@98:             EC_ERR("FMMU not found. Please report!\n");
fp@73:             return -1;
fp@73:         }
fp@98:     }
fp@98: 
fp@98:     // Kommando-Array erzeugen
fp@98:     domain->command_count = domain->data_size / EC_MAX_DATA_SIZE + 1;
fp@98:     if (!(domain->commands = (ec_command_t *) kmalloc(sizeof(ec_command_t)
fp@98:                                                       * domain->command_count,
fp@98:                                                       GFP_KERNEL))) {
fp@98:         EC_ERR("Failed to allocate domain command array!\n");
fp@98:         return -1;
fp@98:     }
fp@98: 
fp@98:     EC_INFO("Domain %X - Allocated %i bytes in %i command(s)\n",
fp@98:             (u32) domain, domain->data_size, domain->command_count);
fp@98: 
fp@98:     ec_domain_clear_field_regs(domain);
fp@73: 
fp@73:     return 0;
fp@73: }
fp@73: 
fp@97: /*****************************************************************************/
fp@97: 
fp@97: /**
fp@97:    Gibt die Anzahl der antwortenden Slaves aus.
fp@97: */
fp@97: 
fp@97: void ec_domain_response_count(ec_domain_t *domain, /**< Domäne */
fp@97:                               unsigned int count /**< Neue Anzahl */
fp@97:                               )
fp@97: {
fp@97:     if (count != domain->response_count) {
fp@97:         domain->response_count = count;
fp@98:         EC_INFO("Domain %08X state change - %i slave%s responding.\n",
fp@98:                 (u32) domain, count, count == 1 ? "" : "s");
fp@97:     }
fp@97: }
fp@97: 
fp@73: /******************************************************************************
fp@73:  *
fp@73:  * Echtzeitschnittstelle
fp@73:  *
fp@73:  *****************************************************************************/
fp@73: 
fp@73: /**
fp@91:    Registriert ein Datenfeld innerhalb einer Domäne.
fp@73: 
fp@73:    \return Zeiger auf den Slave bei Erfolg, sonst NULL
fp@73: */
fp@73: 
fp@98: ec_slave_t *EtherCAT_rt_register_slave_field(ec_domain_t *domain,
fp@98:                                              /**< Domäne */
fp@98:                                              const char *address,
fp@98:                                              /**< ASCII-Addresse des Slaves,
fp@98:                                                 siehe ec_master_slave_address()
fp@98:                                              */
fp@98:                                              const char *vendor_name,
fp@98:                                              /**< Herstellername */
fp@98:                                              const char *product_name,
fp@98:                                              /**< Produktname */
fp@98:                                              void **data_ptr,
fp@98:                                              /**< Adresse des Zeigers auf die
fp@98:                                                 Prozessdaten */
fp@98:                                              ec_field_type_t field_type,
fp@98:                                              /**< Typ des Datenfeldes */
fp@98:                                              unsigned int field_index,
fp@98:                                              /**< Gibt an, ab welchem Feld mit
fp@98:                                                 Typ \a field_type gezählt
fp@98:                                                 werden soll. */
fp@98:                                              unsigned int field_count
fp@98:                                              /**< Anzahl Felder selben Typs */
fp@98:                                              )
fp@73: {
fp@73:     ec_slave_t *slave;
fp@73:     const ec_slave_type_t *type;
fp@73:     ec_master_t *master;
fp@73:     const ec_sync_t *sync;
fp@73:     const ec_field_t *field;
fp@76:     unsigned int field_idx, i, j;
fp@73:     uint32_t field_offset;
fp@73: 
fp@73:     if (!field_count) {
fp@84:         EC_ERR("field_count may not be 0!\n");
fp@73:         return NULL;
fp@73:     }
fp@73: 
fp@73:     master = domain->master;
fp@73: 
fp@73:     // Adresse übersetzen
fp@98:     if (!(slave = ec_master_slave_address(master, address))) return NULL;
fp@73: 
fp@73:     if (!(type = slave->type)) {
fp@84:         EC_ERR("Slave \"%s\" (position %i) has unknown type!\n", address,
fp@84:                slave->ring_position);
fp@73:         return NULL;
fp@73:     }
fp@73: 
fp@73:     if (strcmp(vendor_name, type->vendor_name) ||
fp@73:         strcmp(product_name, type->product_name)) {
fp@84:         EC_ERR("Invalid slave type at position %i - Requested: \"%s %s\","
fp@84:                " found: \"%s %s\".\n", slave->ring_position, vendor_name,
fp@84:                product_name, type->vendor_name, type->product_name);
fp@73:         return NULL;
fp@73:     }
fp@73: 
fp@73:     field_idx = 0;
fp@76:     for (i = 0; type->sync_managers[i]; i++) {
fp@73:         sync = type->sync_managers[i];
fp@73:         field_offset = 0;
fp@73:         for (j = 0; sync->fields[j]; j++) {
fp@73:             field = sync->fields[j];
fp@73:             if (field->type == field_type) {
fp@73:                 if (field_idx == field_index) {
fp@73:                     ec_domain_reg_field(domain, slave, sync, field_offset,
fp@73:                                         data_ptr++);
fp@73:                     if (!(--field_count)) return slave;
fp@73:                 }
fp@73:                 field_idx++;
fp@73:             }
fp@73:             field_offset += field->size;
fp@73:         }
fp@73:     }
fp@73: 
fp@84:     EC_ERR("Slave %i (\"%s %s\") registration mismatch: Type %i, index %i,"
fp@84:            " count %i.\n", slave->ring_position, vendor_name, product_name,
fp@84:            field_type, field_index, field_count);
fp@73:     return NULL;
fp@73: }
fp@73: 
fp@73: /*****************************************************************************/
fp@73: 
fp@73: /**
fp@98:    Registriert eine ganze Liste von Datenfeldern innerhalb einer Domäne.
fp@98: 
fp@98:    Achtung: Die Liste muss mit einer NULL-Struktur ({}) abgeschlossen sein!
fp@73: 
fp@73:    \return 0 bei Erfolg, sonst < 0
fp@73: */
fp@73: 
fp@98: int EtherCAT_rt_register_domain_fields(ec_domain_t *domain,
fp@98:                                        /**< Domäne */
fp@98:                                        ec_field_init_t *fields
fp@98:                                        /**< Array mit Datenfeldern */
fp@98:                                        )
fp@98: {
fp@98:     ec_field_init_t *field;
fp@98: 
fp@98:     for (field = fields; field->data; field++) {
fp@98:         if (!EtherCAT_rt_register_slave_field(domain, field->address,
fp@98:                                               field->vendor, field->product,
fp@98:                                               field->data, field->field_type,
fp@98:                                               field->field_index,
fp@98:                                               field->field_count)) {
fp@98:             return -1;
fp@98:         }
fp@98:     }
fp@98: 
fp@98:     return 0;
fp@98: }
fp@98: 
fp@98: /*****************************************************************************/
fp@98: 
fp@98: /**
fp@98:    Setzt Prozessdaten-Kommandos in die Warteschlange des Masters.
fp@98: */
fp@98: 
fp@98: void EtherCAT_rt_domain_queue(ec_domain_t *domain /**< Domäne */)
fp@98: {
fp@101:     unsigned int i;
fp@98:     size_t size;
fp@101:     off_t offset;
fp@73: 
fp@73:     offset = 0;
fp@98:     for (i = 0; i < domain->command_count; i++) {
fp@73:         size = domain->data_size - offset;
fp@73:         if (size > EC_MAX_DATA_SIZE) size = EC_MAX_DATA_SIZE;
fp@98:         ec_command_init_lrw(domain->commands + i,
fp@98:                             domain->base_address + offset, size,
fp@98:                             domain->data + offset);
fp@98:         ec_master_queue_command(domain->master, domain->commands + i);
fp@73:         offset += size;
fp@73:     }
fp@98: }
fp@98: 
fp@98: /*****************************************************************************/
fp@98: 
fp@98: /**
fp@98:    Verarbeitet empfangene Prozessdaten.
fp@98: */
fp@98: 
fp@98: void EtherCAT_rt_domain_process(ec_domain_t *domain /**< Domäne */)
fp@98: {
fp@101:     unsigned int working_counter_sum, i;
fp@98:     ec_command_t *command;
fp@98:     size_t size;
fp@101:     off_t offset;
fp@98: 
fp@98:     working_counter_sum = 0;
fp@98: 
fp@98:     offset = 0;
fp@98:     for (i = 0; i < domain->command_count; i++) {
fp@98:         command = domain->commands + i;
fp@98:         size = domain->data_size - offset;
fp@98:         if (size > EC_MAX_DATA_SIZE) size = EC_MAX_DATA_SIZE;
fp@98:         if (command->state == EC_CMD_RECEIVED) {
fp@98:             // Daten vom Kommando- in den Prozessdatenspeicher kopieren
fp@98:             memcpy(domain->data + offset, command->data, size);
fp@98:             working_counter_sum += command->working_counter;
fp@98:         }
fp@98:         else if (unlikely(domain->master->debug_level)) {
fp@98:             EC_DBG("process data command not received!\n");
fp@98:         }
fp@98:         offset += size;
fp@98:     }
fp@73: 
fp@97:     ec_domain_response_count(domain, working_counter_sum);
fp@73: }
fp@73: 
fp@73: /*****************************************************************************/
fp@73: 
fp@73: EXPORT_SYMBOL(EtherCAT_rt_register_slave_field);
fp@98: EXPORT_SYMBOL(EtherCAT_rt_register_domain_fields);
fp@98: EXPORT_SYMBOL(EtherCAT_rt_domain_queue);
fp@98: EXPORT_SYMBOL(EtherCAT_rt_domain_process);
fp@42: 
fp@42: /*****************************************************************************/
fp@42: 
fp@42: /* Emacs-Konfiguration
fp@42: ;;; Local Variables: ***
fp@73: ;;; c-basic-offset:4 ***
fp@42: ;;; End: ***
fp@42: */