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@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@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@73:     ec_field_reg_t *field_reg, *next;
fp@73: 
fp@73:     if (domain->data) {
fp@73:         kfree(domain->data);
fp@73:         domain->data = NULL;
fp@73:     }
fp@73: 
fp@73:     // Liste der registrierten Datenfelder löschen
fp@73:     list_for_each_entry_safe(field_reg, next, &domain->field_regs, list) {
fp@73:         kfree(field_reg);
fp@73:     }
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@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@73:     ec_field_reg_t *field_reg, *next;
fp@73:     ec_slave_t *slave;
fp@73:     ec_fmmu_t *fmmu;
fp@73:     unsigned int i, j, found, 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@73:     }
fp@73:     else {
fp@73:         // Prozessdaten allozieren
fp@73:         if (!(domain->data = kmalloc(domain->data_size, GFP_KERNEL))) {
fp@84:             EC_ERR("Failed to allocate domain data!\n");
fp@73:             return -1;
fp@73:         }
fp@73: 
fp@73:         // Prozessdaten mit Nullen vorbelegen
fp@73:         memset(domain->data, 0x00, domain->data_size);
fp@73: 
fp@73:         // Alle Prozessdatenzeiger setzen
fp@73:         list_for_each_entry(field_reg, &domain->field_regs, list) {
fp@73:             found = 0;
fp@73:             for (i = 0; i < field_reg->slave->fmmu_count; i++) {
fp@73:                 fmmu = &field_reg->slave->fmmus[i];
fp@73:                 if (fmmu->domain == domain && fmmu->sync == field_reg->sync) {
fp@73:                     data_offset = fmmu->logical_start_address - base_address
fp@73:                         + field_reg->field_offset;
fp@73:                     *field_reg->data_ptr = domain->data + data_offset;
fp@73:                     found = 1;
fp@73:                     break;
fp@73:                 }
fp@73:             }
fp@73: 
fp@73:             if (!found) { // Sollte nie passieren
fp@84:                 EC_ERR("FMMU not found. Please report!\n");
fp@73:                 return -1;
fp@73:             }
fp@73:         }
fp@73:     }
fp@73: 
fp@73:     // Registrierungsliste wird jetzt nicht mehr gebraucht.
fp@73:     list_for_each_entry_safe(field_reg, next, &domain->field_regs, list) {
fp@73:         kfree(field_reg);
fp@73:     }
fp@73:     INIT_LIST_HEAD(&domain->field_regs); // wichtig!
fp@73: 
fp@73:     return 0;
fp@73: }
fp@73: 
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@73: ec_slave_t *EtherCAT_rt_register_slave_field(
fp@73:     ec_domain_t *domain, /**< Domäne */
fp@73:     const char *address, /**< ASCII-Addresse des Slaves, siehe ec_address() */
fp@73:     const char *vendor_name, /**< Herstellername */
fp@73:     const char *product_name, /**< Produktname */
fp@73:     void **data_ptr, /**< Adresse des Zeigers auf die Prozessdaten */
fp@73:     ec_field_type_t field_type, /**< Typ des Datenfeldes */
fp@73:     unsigned int field_index, /**< Gibt an, ab welchem Feld mit Typ
fp@73:                                  \a field_type gezählt werden soll. */
fp@73:     unsigned int field_count /**< Anzahl Felder des selben Typs */
fp@73:     )
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@73:     if ((slave = ec_address(master, address)) == NULL) 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@91:    Sendet und empfängt Prozessdaten der angegebenen Domäne.
fp@73: 
fp@73:    \return 0 bei Erfolg, sonst < 0
fp@73: */
fp@73: 
fp@73: int EtherCAT_rt_domain_xio(ec_domain_t *domain /**< Domäne */)
fp@73: {
fp@73:     unsigned int offset, size, working_counter_sum;
fp@73:     unsigned long start_ticks, end_ticks, timeout_ticks;
fp@73:     ec_master_t *master;
fp@73:     ec_frame_t *frame;
fp@73: 
fp@73:     master = domain->master;
fp@73:     frame = &domain->frame;
fp@73:     working_counter_sum = 0;
fp@73: 
fp@73:     ec_output_lost_frames(master); // Evtl. verlorene Frames ausgeben
fp@73: 
fp@73:     rdtscl(start_ticks); // Sendezeit nehmen
fp@73:     timeout_ticks = domain->timeout_us * cpu_khz / 1000;
fp@73: 
fp@73:     offset = 0;
fp@73:     while (offset < domain->data_size)
fp@73:     {
fp@73:         size = domain->data_size - offset;
fp@73:         if (size > EC_MAX_DATA_SIZE) size = EC_MAX_DATA_SIZE;
fp@73: 
fp@73:         ec_frame_init_lrw(frame, master, domain->base_address + offset, size,
fp@73:                           domain->data + offset);
fp@73: 
fp@73:         if (unlikely(ec_frame_send(frame) < 0)) {
fp@84:             EC_ERR("Could not send process data command!\n");
fp@73:             return -1;
fp@73:         }
fp@73: 
fp@73:         // Warten
fp@73:         do {
fp@73:             ec_device_call_isr(&master->device);
fp@73:             rdtscl(end_ticks); // Empfangszeit nehmen
fp@73:         }
fp@73:         while (unlikely(master->device.state == EC_DEVICE_STATE_SENT
fp@73:                         && end_ticks - start_ticks < timeout_ticks));
fp@73: 
fp@73:         master->bus_time = (end_ticks - start_ticks) * 1000 / cpu_khz;
fp@73: 
fp@73:         if (unlikely(end_ticks - start_ticks >= timeout_ticks)) {
fp@73:             master->device.state = EC_DEVICE_STATE_READY;
fp@73:             master->frames_lost++;
fp@73:             ec_output_lost_frames(master);
fp@73:             return -1;
fp@73:         }
fp@73: 
fp@73:         if (unlikely(ec_frame_receive(frame) < 0)) {
fp@90:             EC_ERR("Receiving process data failed!\n");
fp@73:             return -1;
fp@73:         }
fp@73: 
fp@73:         working_counter_sum += frame->working_counter;
fp@73: 
fp@73:         // Daten vom Rahmen in den Prozessdatenspeicher kopieren
fp@73:         memcpy(domain->data + offset, frame->data, size);
fp@73: 
fp@73:         offset += size;
fp@73:     }
fp@73: 
fp@73:     if (working_counter_sum != domain->response_count) {
fp@73:         domain->response_count = working_counter_sum;
fp@84:         EC_INFO("Domain %08X state change - %i slaves responding.\n",
fp@84:                 (u32) domain, working_counter_sum);
fp@73:     }
fp@73: 
fp@73:     return 0;
fp@73: }
fp@73: 
fp@73: /*****************************************************************************/
fp@73: 
fp@73: EXPORT_SYMBOL(EtherCAT_rt_register_slave_field);
fp@73: EXPORT_SYMBOL(EtherCAT_rt_domain_xio);
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: */