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@104:                     ec_master_t *master /**< Zugehöriger Master */
fp@73:                     )
fp@73: {
fp@73:     domain->master = master;
fp@73:     domain->data_size = 0;
fp@73:     domain->base_address = 0;
fp@73:     domain->response_count = 0xFFFFFFFF;
fp@73: 
fp@73:     INIT_LIST_HEAD(&domain->field_regs);
fp@144:     INIT_LIST_HEAD(&domain->commands);
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@144:     ec_command_t *command, *next;
fp@144: 
fp@144:     list_for_each_entry_safe(command, next, &domain->commands, list) {
fp@144:         ec_command_clear(command);
fp@144:         kfree(command);
fp@144:     }
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@144:     if (!(field_reg =
fp@144:           (ec_field_reg_t *) kmalloc(sizeof(ec_field_reg_t), 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@144:    Alloziert ein Prozessdatenkommando und fügt es in die Liste ein.
fp@144: */
fp@144: 
fp@144: int ec_domain_add_command(ec_domain_t *domain, /**< Domäne */
fp@144:                           uint32_t offset, /**< Logisches Offset */
fp@144:                           size_t data_size /**< Größe der Kommando-Daten */
fp@144:                           )
fp@144: {
fp@144:     ec_command_t *command;
fp@144: 
fp@144:     if (!(command = kmalloc(sizeof(ec_command_t), GFP_KERNEL))) {
fp@144:         EC_ERR("Failed to allocate domain command!\n");
fp@144:         return -1;
fp@144:     }
fp@144: 
fp@144:     ec_command_init(command);
fp@144: 
fp@144:     if (ec_command_lrw(command, offset, data_size)) {
fp@144:         kfree(command);
fp@144:         return -1;
fp@144:     }
fp@144: 
fp@144:     list_add_tail(&command->list, &domain->commands);
fp@144:     return 0;
fp@144: }
fp@144: 
fp@144: /*****************************************************************************/
fp@144: 
fp@144: /**
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@144:     unsigned int i, j, cmd_count;
fp@144:     uint32_t field_off, field_off_cmd;
fp@144:     uint32_t cmd_offset;
fp@144:     size_t cmd_data_size;
fp@144:     ec_command_t *command;
fp@73: 
fp@73:     domain->base_address = base_address;
fp@73: 
fp@144:     // Größe der Prozessdaten berechnen und Kommandos allozieren
fp@73:     domain->data_size = 0;
fp@144:     cmd_offset = base_address;
fp@144:     cmd_data_size = 0;
fp@144:     cmd_count = 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@144:                 if (cmd_data_size + fmmu->sync->size > EC_MAX_DATA_SIZE) {
fp@144:                     if (ec_domain_add_command(domain, cmd_offset,
fp@144:                                               cmd_data_size)) return -1;
fp@144:                     cmd_offset += cmd_data_size;
fp@144:                     cmd_data_size = 0;
fp@144:                     cmd_count++;
fp@144:                 }
fp@144:                 cmd_data_size += fmmu->sync->size;
fp@73:             }
fp@73:         }
fp@73:     }
fp@73: 
fp@144:     // Letztes Kommando allozieren
fp@144:     if (cmd_data_size) {
fp@144:         if (ec_domain_add_command(domain, cmd_offset, cmd_data_size))
fp@144:             return -1;
fp@144:         cmd_count++;
fp@144:     }
fp@144: 
fp@144:     if (!cmd_count) {
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:     // Alle Prozessdatenzeiger setzen
fp@98:     list_for_each_entry(field_reg, &domain->field_regs, list) {
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@144:                 field_off = fmmu->logical_start_address +
fp@144:                     field_reg->field_offset;
fp@144:                 // Kommando suchen
fp@144:                 list_for_each_entry(command, &domain->commands, list) {
fp@144:                     field_off_cmd = field_off - command->address.logical;
fp@144:                     if (field_off >= command->address.logical &&
fp@144:                         field_off_cmd < command->mem_size) {
fp@144:                         *field_reg->data_ptr = command->data + field_off_cmd;
fp@144:                     }
fp@144:                 }
fp@144:                 if (!field_reg->data_ptr) {
fp@144:                     EC_ERR("Failed to assign data pointer!\n");
fp@144:                     return -1;
fp@144:                 }
fp@98:                 break;
fp@98:             }
fp@98:         }
fp@98:     }
fp@98: 
fp@98:     EC_INFO("Domain %X - Allocated %i bytes in %i command(s)\n",
fp@144:             (u32) domain, domain->data_size, cmd_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@112:    - Ist \a data_ptr NULL, so wird der Slave nur auf den Typ überprüft.
fp@112:    - Wenn \a field_count 0 ist, wird angenommen, dass 1 Feld registriert werden
fp@112:      soll.
fp@112:    - Wenn \a field_count größer als 1 ist, wird angenommen, dass \a data_ptr
fp@112:      auf ein entsprechend großes Array zeigt.
fp@112: 
fp@73:    \return Zeiger auf den Slave bei Erfolg, sonst NULL
fp@73: */
fp@73: 
fp@104: ec_slave_t *ecrt_domain_register_field(ec_domain_t *domain,
fp@104:                                        /**< Domäne */
fp@104:                                        const char *address,
fp@104:                                        /**< ASCII-Addresse des Slaves,
fp@138:                                           siehe ecrt_master_get_slave() */
fp@104:                                        const char *vendor_name,
fp@104:                                        /**< Herstellername */
fp@104:                                        const char *product_name,
fp@104:                                        /**< Produktname */
fp@104:                                        void **data_ptr,
fp@104:                                        /**< Adresse des Zeigers auf die
fp@104:                                           Prozessdaten */
fp@104:                                        const char *field_name,
fp@104:                                        /**< Name des Datenfeldes */
fp@104:                                        unsigned int field_index,
fp@104:                                        /**< Gibt an, ab welchem Feld mit
fp@104:                                           Typ \a field_type gezählt
fp@104:                                           werden soll. */
fp@104:                                        unsigned int field_count
fp@104:                                        /**< Anzahl Felder selben Typs */
fp@104:                                        )
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@108:     unsigned int field_counter, i, j, orig_field_index, orig_field_count;
fp@73:     uint32_t field_offset;
fp@73: 
fp@73:     master = domain->master;
fp@73: 
fp@73:     // Adresse übersetzen
fp@138:     if (!(slave = ecrt_master_get_slave(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@112:     if (!data_ptr) {
fp@112:         // Wenn data_ptr NULL, Slave als registriert ansehen (nicht warnen).
fp@112:         slave->registered = 1;
fp@112:     }
fp@112: 
fp@112:     if (!field_count) field_count = 1;
fp@108:     orig_field_index = field_index;
fp@108:     orig_field_count = field_count;
fp@108: 
fp@108:     field_counter = 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@104:             if (!strcmp(field->name, field_name)) {
fp@108:                 if (field_counter++ == field_index) {
fp@112:                     if (data_ptr)
fp@112:                         ec_domain_reg_field(domain, slave, sync, field_offset,
fp@112:                                             data_ptr++);
fp@73:                     if (!(--field_count)) return slave;
fp@108:                     field_index++;
fp@73:                 }
fp@73:             }
fp@73:             field_offset += field->size;
fp@73:         }
fp@73:     }
fp@73: 
fp@104:     EC_ERR("Slave %i (\"%s %s\") registration mismatch: Field \"%s\","
fp@104:            " index %i, count %i.\n", slave->ring_position, vendor_name,
fp@108:            product_name, field_name, orig_field_index, orig_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@104: int ecrt_domain_register_field_list(ec_domain_t *domain,
fp@104:                                     /**< Domäne */
fp@104:                                     ec_field_init_t *fields
fp@104:                                     /**< Array mit Datenfeldern */
fp@104:                                     )
fp@98: {
fp@98:     ec_field_init_t *field;
fp@98: 
fp@112:     for (field = fields; field->slave_address; field++)
fp@104:         if (!ecrt_domain_register_field(domain, field->slave_address,
fp@104:                                         field->vendor_name,
fp@104:                                         field->product_name, field->data_ptr,
fp@104:                                         field->field_name, field->field_index,
fp@104:                                         field->field_count))
fp@98:             return -1;
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@104: void ecrt_domain_queue(ec_domain_t *domain /**< Domäne */)
fp@98: {
fp@144:     ec_command_t *command;
fp@144: 
fp@144:     list_for_each_entry(command, &domain->commands, list) {
fp@144:         ec_master_queue_command(domain->master, command);
fp@73:     }
fp@98: }
fp@98: 
fp@98: /*****************************************************************************/
fp@98: 
fp@98: /**
fp@98:    Verarbeitet empfangene Prozessdaten.
fp@98: */
fp@98: 
fp@104: void ecrt_domain_process(ec_domain_t *domain /**< Domäne */)
fp@98: {
fp@144:     unsigned int working_counter_sum;
fp@98:     ec_command_t *command;
fp@98: 
fp@98:     working_counter_sum = 0;
fp@98: 
fp@144:     list_for_each_entry(command, &domain->commands, list) {
fp@98:         if (command->state == EC_CMD_RECEIVED) {
fp@98:             working_counter_sum += command->working_counter;
fp@98:         }
fp@98:     }
fp@73: 
fp@97:     ec_domain_response_count(domain, working_counter_sum);
fp@73: }
fp@73: 
fp@73: /*****************************************************************************/
fp@73: 
fp@105: /**
fp@105:    Gibt den Status einer Domäne zurück.
fp@105: 
fp@105:    \return 0 wenn alle Kommandos empfangen wurden, sonst -1.
fp@105: */
fp@105: 
fp@105: int ecrt_domain_state(ec_domain_t *domain /**< Domäne */)
fp@105: {
fp@105:     ec_command_t *command;
fp@105: 
fp@144:     list_for_each_entry(command, &domain->commands, list) {
fp@105:         if (command->state != EC_CMD_RECEIVED) return -1;
fp@105:     }
fp@105: 
fp@105:     return 0;
fp@105: }
fp@105: 
fp@105: /*****************************************************************************/
fp@105: 
fp@104: EXPORT_SYMBOL(ecrt_domain_register_field);
fp@104: EXPORT_SYMBOL(ecrt_domain_register_field_list);
fp@104: EXPORT_SYMBOL(ecrt_domain_queue);
fp@104: EXPORT_SYMBOL(ecrt_domain_process);
fp@105: EXPORT_SYMBOL(ecrt_domain_state);
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: */