etherlabmaster: comparison master/slave.c

equal deleted inserted replaced

-:1a7067207637
+:7bc131b92039
 void ec_slave_clear(struct kobject *);
 void ec_slave_sdos_clear(struct kobject *);
 ssize_t ec_show_slave_attribute(struct kobject *, struct attribute *, char *);
 ssize_t ec_store_slave_attribute(struct kobject *, struct attribute *,
 const char *, size_t);
+char *ec_slave_sii_string(ec_slave_t *, unsigned int);
 /*****************************************************************************/
 /** \cond */
 EC_SYSFS_READ_ATTR(info);
 EC_SYSFS_READ_WRITE_ATTR(state);
 EC_SYSFS_READ_WRITE_ATTR(eeprom);
+EC_SYSFS_READ_WRITE_ATTR(alias);
 static struct attribute *def_attrs[] = {
 &attr_info,
 &attr_state,
 &attr_eeprom,
+&attr_alias,
 NULL,
 };
 static struct sysfs_ops sysfs_ops = {
 .show = ec_show_slave_attribute,
 slave->ring_position = ring_position;
 slave->station_address = station_address;
 slave->master = master;
-slave->requested_state = EC_SLAVE_STATE_UNKNOWN;
+slave->requested_state = EC_SLAVE_STATE_PREOP;
 slave->current_state = EC_SLAVE_STATE_UNKNOWN;
 slave->self_configured = 0;
 slave->error_flag = 0;
-slave->online = 1;
+slave->online_state = EC_SLAVE_ONLINE;
 slave->fmmu_count = 0;
+slave->pdos_registered = 0;
-slave->coupler_index = 0;
-slave->coupler_subindex = 0xFFFF;
 slave->base_type = 0;
 slave->base_revision = 0;
 slave->base_build = 0;
 slave->base_fmmu_count = 0;
-slave->base_sync_count = 0;
 slave->eeprom_data = NULL;
 slave->eeprom_size = 0;
-slave->new_eeprom_data = NULL;
-slave->new_eeprom_size = 0;
 slave->sii_alias = 0;
 slave->sii_vendor_id = 0;
 slave->sii_product_code = 0;
 slave->sii_revision_number = 0;
 slave->sii_image = NULL;
 slave->sii_order = NULL;
 slave->sii_name = NULL;
 slave->sii_current_on_ebus = 0;
-INIT_LIST_HEAD(&slave->sii_strings);
+slave->sii_strings = NULL;
-INIT_LIST_HEAD(&slave->sii_syncs);
+slave->sii_string_count = 0;
+slave->sii_syncs = NULL;
+slave->sii_sync_count = 0;
 INIT_LIST_HEAD(&slave->sii_pdos);
 INIT_LIST_HEAD(&slave->sdo_dictionary);
 INIT_LIST_HEAD(&slave->sdo_confs);
 slave->sdo_dictionary_fetched = 0;
 */
 void ec_slave_clear(struct kobject *kobj /**< kobject of the slave */)
 {
 ec_slave_t *slave;
-ec_sii_string_t *string, *next_str;
+ec_pdo_t *pdo, *next_pdo;
-ec_sii_sync_t *sync, *next_sync;
-ec_sii_pdo_t *pdo, *next_pdo;
-ec_sii_pdo_entry_t *entry, *next_ent;
 ec_sdo_data_t *sdodata, *next_sdodata;
+unsigned int i;
 slave = container_of(kobj, ec_slave_t, kobj);
-// free all string objects
+// free all strings
-list_for_each_entry_safe(string, next_str, &slave->sii_strings, list) {
+if (slave->sii_strings) {
-list_del(&string->list);
+for (i = 0; i < slave->sii_string_count; i++)
-kfree(string);
+kfree(slave->sii_strings[i]);
+kfree(slave->sii_strings);
 }
 // free all sync managers
-list_for_each_entry_safe(sync, next_sync, &slave->sii_syncs, list) {
+if (slave->sii_syncs) {
-list_del(&sync->list);
+for (i = 0; i < slave->sii_sync_count; i++) {
-kfree(sync);
+ec_sync_clear(&slave->sii_syncs[i]);
 }
+kfree(slave->sii_syncs);
-// free all PDOs
+}
+// free all SII PDOs
 list_for_each_entry_safe(pdo, next_pdo, &slave->sii_pdos, list) {
 list_del(&pdo->list);
-if (pdo->name) kfree(pdo->name);
+ec_pdo_clear(pdo);
-// free all PDO entries
-list_for_each_entry_safe(entry, next_ent, &pdo->entries, list) {
-list_del(&entry->list);
-if (entry->name) kfree(entry->name);
-kfree(entry);
-}
 kfree(pdo);
 }
-if (slave->sii_group) kfree(slave->sii_group);
-if (slave->sii_image) kfree(slave->sii_image);
-if (slave->sii_order) kfree(slave->sii_order);
-if (slave->sii_name) kfree(slave->sii_name);
 // free all SDO configurations
 list_for_each_entry_safe(sdodata, next_sdodata, &slave->sdo_confs, list) {
 list_del(&sdodata->list);
 kfree(sdodata->data);
 kfree(sdodata);
 }
 if (slave->eeprom_data) kfree(slave->eeprom_data);
-if (slave->new_eeprom_data) kfree(slave->new_eeprom_data);
 kfree(slave);
 }
 /*****************************************************************************/
 */
 void ec_slave_reset(ec_slave_t *slave /**< EtherCAT slave */)
 {
 ec_sdo_data_t *sdodata, *next_sdodata;
-ec_sii_sync_t *sync;
+unsigned int i;
-// remove FMMU configurations
 slave->fmmu_count = 0;
+slave->pdos_registered = 0;
 // free all SDO configurations
 list_for_each_entry_safe(sdodata, next_sdodata, &slave->sdo_confs, list) {
 list_del(&sdodata->list);
 kfree(sdodata->data);
 kfree(sdodata);
 }
 // remove estimated sync manager sizes
-list_for_each_entry(sync, &slave->sii_syncs, list) {
+for (i = 0; i < slave->sii_sync_count; i++) {
-sync->est_length = 0;
+slave->sii_syncs[i].est_length = 0;
 }
 }
 /*****************************************************************************/
 /**
+* Sets the application state of a slave.
 */
-void ec_slave_request_state(ec_slave_t *slave, /**< ETherCAT slave */
+void ec_slave_set_state(ec_slave_t *slave, /**< EtherCAT slave */
+ec_slave_state_t new_state /**< new application state */
+)
+{
+if (new_state != slave->current_state) {
+if (slave->master->debug_level) {
+char old_state[EC_STATE_STRING_SIZE],
+cur_state[EC_STATE_STRING_SIZE];
+ec_state_string(slave->current_state, old_state);
+ec_state_string(new_state, cur_state);
+EC_DBG("Slave %i: %s -> %s.\n",
+slave->ring_position, old_state, cur_state);
+}
+slave->current_state = new_state;
+}
+}
+/*****************************************************************************/
+/**
+* Sets the online state of a slave.
+*/
+void ec_slave_set_online_state(ec_slave_t *slave, /**< EtherCAT slave */
+ec_slave_online_state_t new_state /**< new online state */
+)
+{
+if (new_state == EC_SLAVE_OFFLINE &&
+slave->online_state == EC_SLAVE_ONLINE) {
+if (slave->pdos_registered)
+slave->master->pdo_slaves_offline++;
+if (slave->master->debug_level)
+EC_DBG("Slave %i: offline.\n", slave->ring_position);
+}
+else if (new_state == EC_SLAVE_ONLINE &&
+slave->online_state == EC_SLAVE_OFFLINE) {
+slave->error_flag = 0; // clear error flag
+if (slave->pdos_registered)
+slave->master->pdo_slaves_offline--;
+if (slave->master->debug_level) {
+char cur_state[EC_STATE_STRING_SIZE];
+ec_state_string(slave->current_state, cur_state);
+EC_DBG("Slave %i: online (%s).\n",
+slave->ring_position, cur_state);
+}
+}
+slave->online_state = new_state;
+}
+/*****************************************************************************/
+/**
+*/
+void ec_slave_request_state(ec_slave_t *slave, /**< EtherCAT slave */
 ec_slave_state_t state /**< new state */
 )
 {
 slave->requested_state = state;
 slave->error_flag = 0;
 /**
 Fetches data from a STRING category.
 \return 0 in case of success, else < 0
 */
-int ec_slave_fetch_strings(ec_slave_t *slave, /**< EtherCAT slave */
+int ec_slave_fetch_sii_strings(
-const uint8_t *data /**< category data */
+ec_slave_t *slave, /**< EtherCAT slave */
-)
+const uint8_t *data /**< category data */
-{
+)
-unsigned int string_count, i;
+{
+int i;
 size_t size;
 off_t offset;
-ec_sii_string_t *string;
+slave->sii_string_count = data[0];
-string_count = data[0];
+if (!slave->sii_string_count)
+return 0;
+if (!(slave->sii_strings =
+kmalloc(sizeof(char *) * slave->sii_string_count,
+GFP_KERNEL))) {
+EC_ERR("Failed to allocate string array memory.\n");
+goto out_zero;
+}
 offset = 1;
-for (i = 0; i < string_count; i++) {
+for (i = 0; i < slave->sii_string_count; i++) {
 size = data[offset];
 // allocate memory for string structure and data at a single blow
-if (!(string = (ec_sii_string_t *)
+if (!(slave->sii_strings[i] =
-kmalloc(sizeof(ec_sii_string_t) + size + 1, GFP_ATOMIC))) {
+kmalloc(sizeof(char) * size + 1, GFP_KERNEL))) {
 EC_ERR("Failed to allocate string memory.\n");
-return -1;
+goto out_free;
 }
-string->size = size;
+memcpy(slave->sii_strings[i], data + offset + 1, size);
-// string memory appended to string structure
+slave->sii_strings[i][size] = 0x00; // append binary zero
-string->data = (char *) string + sizeof(ec_sii_string_t);
-memcpy(string->data, data + offset + 1, size);
-string->data[size] = 0x00;
-list_add_tail(&string->list, &slave->sii_strings);
 offset += 1 + size;
 }
 return 0;
+out_free:
+for (i--; i >= 0; i--) kfree(slave->sii_strings[i]);
+kfree(slave->sii_strings);
+slave->sii_strings = NULL;
+out_zero:
+slave->sii_string_count = 0;
+return -1;
 }
 /*****************************************************************************/
 /**
 Fetches data from a GENERAL category.
 \return 0 in case of success, else < 0
 */
-void ec_slave_fetch_general(ec_slave_t *slave, /**< EtherCAT slave */
+void ec_slave_fetch_sii_general(
-const uint8_t *data /**< category data */
+ec_slave_t *slave, /**< EtherCAT slave */
-)
+const uint8_t *data /**< category data */
+)
 {
 unsigned int i;
-ec_slave_locate_string(slave, data[0], &slave->sii_group);
+slave->sii_group = ec_slave_sii_string(slave, data[0]);
-ec_slave_locate_string(slave, data[1], &slave->sii_image);
+slave->sii_image = ec_slave_sii_string(slave, data[1]);
-ec_slave_locate_string(slave, data[2], &slave->sii_order);
+slave->sii_order = ec_slave_sii_string(slave, data[2]);
-ec_slave_locate_string(slave, data[3], &slave->sii_name);
+slave->sii_name = ec_slave_sii_string(slave, data[3]);
 for (i = 0; i < 4; i++)
 slave->sii_physical_layer[i] =
 (data[4] & (0x03 << (i * 2))) >> (i * 2);
 /**
 Fetches data from a SYNC MANAGER category.
 \return 0 in case of success, else < 0
 */
-int ec_slave_fetch_sync(ec_slave_t *slave, /**< EtherCAT slave */
+int ec_slave_fetch_sii_syncs(
-const uint8_t *data, /**< category data */
+ec_slave_t *slave, /**< EtherCAT slave */
-size_t word_count /**< number of words */
+const uint8_t *data, /**< category data */
-)
+size_t word_count /**< number of words */
-{
+)
-unsigned int sync_count, i;
+{
-ec_sii_sync_t *sync;
+unsigned int i;
+ec_sync_t *sync;
-sync_count = word_count / 4; // sync manager struct is 4 words long
+// sync manager struct is 4 words long
-for (i = 0; i < sync_count; i++, data += 8) {
+slave->sii_sync_count = word_count / 4;
-if (!(sync = (ec_sii_sync_t *)
-kmalloc(sizeof(ec_sii_sync_t), GFP_ATOMIC))) {
+if (!(slave->sii_syncs =
-EC_ERR("Failed to allocate Sync-Manager memory.\n");
+kmalloc(sizeof(ec_sync_t) * slave->sii_sync_count,
-return -1;
+GFP_KERNEL))) {
-}
+EC_ERR("Failed to allocate memory for sync managers.\n");
+slave->sii_sync_count = 0;
-sync->index = i;
+return -1;
+}
+for (i = 0; i < slave->sii_sync_count; i++, data += 8) {
+sync = &slave->sii_syncs[i];
+ec_sync_init(sync, slave, i);
 sync->physical_start_address = EC_READ_U16(data);
-sync->length                 = EC_READ_U16(data + 2);
+sync->length = EC_READ_U16(data + 2);
-sync->control_register       = EC_READ_U8 (data + 4);
+sync->control_register = EC_READ_U8 (data + 4);
-sync->enable                 = EC_READ_U8 (data + 6);
+sync->enable = EC_READ_U8 (data + 6);
-sync->est_length = 0;
-list_add_tail(&sync->list, &slave->sii_syncs);
 }
 return 0;
 }
 /**
 Fetches data from a [RT]XPDO category.
 \return 0 in case of success, else < 0
 */
-int ec_slave_fetch_pdo(ec_slave_t *slave, /**< EtherCAT slave */
+int ec_slave_fetch_sii_pdos(
-const uint8_t *data, /**< category data */
+ec_slave_t *slave, /**< EtherCAT slave */
-size_t word_count, /**< number of words */
+const uint8_t *data, /**< category data */
-ec_sii_pdo_type_t pdo_type /**< PDO type */
+size_t word_count, /**< number of words */
-)
+ec_pdo_type_t pdo_type /**< PDO type */
-{
+)
-ec_sii_pdo_t *pdo;
+{
-ec_sii_pdo_entry_t *entry;
+ec_pdo_t *pdo;
+ec_pdo_entry_t *entry;
 unsigned int entry_count, i;
 while (word_count >= 4) {
-if (!(pdo = (ec_sii_pdo_t *)
+if (!(pdo = kmalloc(sizeof(ec_pdo_t), GFP_KERNEL))) {
-kmalloc(sizeof(ec_sii_pdo_t), GFP_ATOMIC))) {
 EC_ERR("Failed to allocate PDO memory.\n");
 return -1;
 }
-INIT_LIST_HEAD(&pdo->entries);
+ec_pdo_init(pdo);
 pdo->type = pdo_type;
 pdo->index = EC_READ_U16(data);
 entry_count = EC_READ_U8(data + 2);
 pdo->sync_index = EC_READ_U8(data + 3);
-pdo->name = NULL;
+pdo->name = ec_slave_sii_string(slave, EC_READ_U8(data + 5));
-ec_slave_locate_string(slave, EC_READ_U8(data + 5), &pdo->name);
 list_add_tail(&pdo->list, &slave->sii_pdos);
 word_count -= 4;
 data += 8;
 for (i = 0; i < entry_count; i++) {
-if (!(entry = (ec_sii_pdo_entry_t *)
+if (!(entry = kmalloc(sizeof(ec_pdo_entry_t), GFP_KERNEL))) {
-kmalloc(sizeof(ec_sii_pdo_entry_t), GFP_ATOMIC))) {
 EC_ERR("Failed to allocate PDO entry memory.\n");
 return -1;
 }
 entry->index = EC_READ_U16(data);
 entry->subindex = EC_READ_U8(data + 2);
-entry->name = NULL;
+entry->name = ec_slave_sii_string(slave, EC_READ_U8(data + 3));
-ec_slave_locate_string(slave, EC_READ_U8(data + 3), &entry->name);
 entry->bit_length = EC_READ_U8(data + 5);
 list_add_tail(&entry->list, &pdo->entries);
 word_count -= 4;
 data += 8;
+}
+// if sync manager index is positive, the PDO is mapped by default
+if (pdo->sync_index >= 0) {
+ec_pdo_t *mapped_pdo;
+if (pdo->sync_index >= slave->sii_sync_count) {
+EC_ERR("Invalid SM index %i for PDO 0x%04X in slave %u.",
+pdo->sync_index, pdo->index, slave->ring_position);
+return -1;
+}
+if (!(mapped_pdo = kmalloc(sizeof(ec_pdo_t), GFP_KERNEL))) {
+EC_ERR("Failed to allocate PDO memory.\n");
+return -1;
+}
+if (ec_pdo_copy(mapped_pdo, pdo)) {
+EC_ERR("Failed to copy PDO.\n");
+kfree(mapped_pdo);
+return -1;
+}
+list_add_tail(&mapped_pdo->list,
+&slave->sii_syncs[pdo->sync_index].pdos);
 }
 }
 return 0;
 }
 Searches the string list for an index and allocates a new string.
 \return 0 in case of success, else < 0
 \todo documentation
 */
-int ec_slave_locate_string(ec_slave_t *slave, /**< EtherCAT slave */
+char *ec_slave_sii_string(
-unsigned int index, /**< string index */
+ec_slave_t *slave, /**< EtherCAT slave */
-char **ptr /**< Address of the string pointer */
+unsigned int index /**< string index */
 )
 {
-ec_sii_string_t *string;
+if (!index--)
-char *err_string;
+return NULL;
-// Erst alten Speicher freigeben
+if (index >= slave->sii_string_count) {
-if (*ptr) {
+if (slave->master->debug_level)
-kfree(*ptr);
+EC_WARN("String %i not found in slave %i.\n",
-*ptr = NULL;
+index, slave->ring_position);
-}
+return NULL;
+}
-// Index 0 bedeutet "nicht belegt"
-if (!index) return 0;
+return slave->sii_strings[index];
+}
-// EEPROM-String mit Index finden und kopieren
-list_for_each_entry(string, &slave->sii_strings, list) {
+/*****************************************************************************/
-if (--index) continue;
+/**
-if (!(*ptr = (char *) kmalloc(string->size + 1, GFP_ATOMIC))) {
+* Prepares an FMMU configuration.
-EC_ERR("Unable to allocate string memory.\n");
+* Configuration data for the FMMU is saved in the slave structure and is
-return -1;
+* written to the slave in ecrt_master_activate().
-}
+* The FMMU configuration is done in a way, that the complete data range
-memcpy(*ptr, string->data, string->size + 1);
+* of the corresponding sync manager is covered. Seperate FMMUs are configured
-return 0;
+* for each domain.
-}
+* If the FMMU configuration is already prepared, the function returns with
+* success.
-if (slave->master->debug_level)
+* \return 0 in case of success, else < 0
-EC_WARN("String %i not found in slave %i.\n",
+*/
-index, slave->ring_position);
+int ec_slave_prepare_fmmu(
-err_string = "(string not found)";
+ec_slave_t *slave, /**< EtherCAT slave */
+const ec_domain_t *domain, /**< domain */
-if (!(*ptr = (char *) kmalloc(strlen(err_string) + 1, GFP_ATOMIC))) {
+const ec_sync_t *sync  /**< sync manager */
-EC_WARN("Unable to allocate string memory.\n");
+)
-return -1;
-}
-memcpy(*ptr, err_string, strlen(err_string) + 1);
-return 0;
-}
-/*****************************************************************************/
-/**
-Prepares an FMMU configuration.
-Configuration data for the FMMU is saved in the slave structure and is
-written to the slave in ecrt_master_activate().
-The FMMU configuration is done in a way, that the complete data range
-of the corresponding sync manager is covered. Seperate FMMUs are configured
-for each domain.
-If the FMMU configuration is already prepared, the function returns with
-success.
-\return 0 in case of success, else < 0
-*/
-int ec_slave_prepare_fmmu(ec_slave_t *slave, /**< EtherCAT slave */
-const ec_domain_t *domain, /**< domain */
-const ec_sii_sync_t *sync  /**< sync manager */
-)
 {
 unsigned int i;
 ec_fmmu_t *fmmu;
 // FMMU configuration already prepared?
 return -1;
 }
 fmmu = &slave->fmmus[slave->fmmu_count];
-fmmu->index = slave->fmmu_count;
+ec_fmmu_init(fmmu, slave, slave->fmmu_count++);
 fmmu->domain = domain;
 fmmu->sync = sync;
 fmmu->logical_start_address = 0;
-slave->fmmu_count++;
+slave->pdos_registered = 1;
+ec_slave_request_state(slave, EC_SLAVE_STATE_OP);
 return 0;
 }
 /*****************************************************************************/
 size_t ec_slave_info(const ec_slave_t *slave, /**< EtherCAT slave */
 char *buffer /**< Output buffer */
 )
 {
 off_t off = 0;
-ec_sii_sync_t *sync;
+ec_sync_t *sync;
-ec_sii_pdo_t *pdo;
+ec_pdo_t *pdo;
-ec_sii_pdo_entry_t *pdo_entry;
+ec_pdo_entry_t *pdo_entry;
 int first, i;
 ec_sdo_data_t *sdodata;
 char str[20];
 off += sprintf(buffer + off, "\nName: ");
 off += sprintf(buffer + off, "State: ");
 off += ec_state_string(slave->current_state, buffer + off);
 off += sprintf(buffer + off, " (");
 off += ec_state_string(slave->requested_state, buffer + off);
 off += sprintf(buffer + off, ")\nFlags: %s, %s\n",
-slave->online ? "online" : "OFFLINE",
+slave->online_state == EC_SLAVE_ONLINE ? "online" : "OFFLINE",
 slave->error_flag ? "ERROR" : "ok");
 off += sprintf(buffer + off, "Ring position: %i\n",
 slave->ring_position);
-off += sprintf(buffer + off, "Advanced position: %i:%i\n",
-slave->coupler_index, slave->coupler_subindex);
-off += sprintf(buffer + off, "Coupler: %s\n",
-ec_slave_is_coupler(slave) ? "yes" : "no");
 off += sprintf(buffer + off, "Current consumption: %i mA\n\n",
 slave->sii_current_on_ebus);
 off += sprintf(buffer + off, "Data link status:\n");
 for (i = 0; i < 4; i++) {
 if (slave->sii_image)
 off += sprintf(buffer + off, "  Image: %s\n", slave->sii_image);
 if (slave->sii_order)
 off += sprintf(buffer + off, "  Order number: %s\n", slave->sii_order);
-if (!list_empty(&slave->sii_syncs))
+if (slave->sii_sync_count)
-off += sprintf(buffer + off, "\nSync-Managers:\n");
+off += sprintf(buffer + off, "\nSync managers / PDO mapping:\n");
-list_for_each_entry(sync, &slave->sii_syncs, list) {
+for (i = 0; i < slave->sii_sync_count; i++) {
-off += sprintf(buffer + off, "  %i: 0x%04X, length %i,"
+sync = &slave->sii_syncs[i];
-" control 0x%02X, %s\n",
+off += sprintf(buffer + off,
-sync->index, sync->physical_start_address,
+"  SM%u: addr 0x%04X, size %i, control 0x%02X, %s\n",
-sync->length, sync->control_register,
+sync->index, sync->physical_start_address,
-sync->enable ? "enable" : "disable");
+ec_sync_size(sync), sync->control_register,
+sync->enable ? "enable" : "disable");
+if (list_empty(&sync->pdos))
+off += sprintf(buffer + off, "    No PDOs mapped.\n");
+list_for_each_entry(pdo, &sync->pdos, list) {
+off += sprintf(buffer + off, "    %s 0x%04X \"%s\"\n",
+pdo->type == EC_RX_PDO ? "RXPDO" : "TXPDO",
+pdo->index, pdo->name ? pdo->name : "???");
+list_for_each_entry(pdo_entry, &pdo->entries, list) {
+off += sprintf(buffer + off,
+"      0x%04X:%X \"%s\", %i bit\n",
+pdo_entry->index, pdo_entry->subindex,
+pdo_entry->name ? pdo_entry->name : "???",
+pdo_entry->bit_length);
+}
+}
 }
 if (!list_empty(&slave->sii_pdos))
-off += sprintf(buffer + off, "\nPDOs:\n");
+off += sprintf(buffer + off, "\nAvailable PDOs:\n");
 list_for_each_entry(pdo, &slave->sii_pdos, list) {
-off += sprintf(buffer + off,
+off += sprintf(buffer + off, "  %s 0x%04X \"%s\"",
-"  %s \"%s\" (0x%04X), Sync-Manager %i\n",
 pdo->type == EC_RX_PDO ? "RXPDO" : "TXPDO",
-pdo->name ? pdo->name : "???",
+pdo->index, pdo->name ? pdo->name : "???");
-pdo->index, pdo->sync_index);
+if (pdo->sync_index >= 0)
+off += sprintf(buffer + off, ", default mapping: SM%u.\n",
+pdo->sync_index);
+else
+off += sprintf(buffer + off, ", no default mapping.\n");
 list_for_each_entry(pdo_entry, &pdo->entries, list) {
-off += sprintf(buffer + off, "    \"%s\" 0x%04X:%X, %i bit\n",
+off += sprintf(buffer + off, "    0x%04X:%X \"%s\", %i bit\n",
+pdo_entry->index, pdo_entry->subindex,
 pdo_entry->name ? pdo_entry->name : "???",
-pdo_entry->index, pdo_entry->subindex,
 pdo_entry->bit_length);
 }
 }
 if (!list_empty(&slave->sdo_confs))
 }
 /*****************************************************************************/
 /**
-Schedules an EEPROM write operation.
+* Schedules an EEPROM write request.
-\return 0 in case of success, else < 0
+* \return 0 case of success, otherwise error code.
 */
+int ec_slave_schedule_eeprom_writing(ec_eeprom_write_request_t *request)
+{
+ec_master_t *master = request->slave->master;
+request->state = EC_REQUEST_QUEUED;
+// schedule EEPROM write request.
+down(&master->eeprom_sem);
+list_add_tail(&request->list, &master->eeprom_requests);
+up(&master->eeprom_sem);
+// wait for processing through FSM
+if (wait_event_interruptible(master->eeprom_queue,
+request->state != EC_REQUEST_QUEUED)) {
+// interrupted by signal
+down(&master->eeprom_sem);
+if (request->state == EC_REQUEST_QUEUED) {
+list_del(&request->list);
+up(&master->eeprom_sem);
+return -EINTR;
+}
+// request already processing: interrupt not possible.
+up(&master->eeprom_sem);
+}
+// wait until master FSM has finished processing
+wait_event(master->eeprom_queue,
+request->state != EC_REQUEST_IN_PROGRESS);
+return request->state == EC_REQUEST_COMPLETE ? 0 : -EIO;
+}
+/*****************************************************************************/
+/**
+* Writes complete EEPROM contents to a slave.
+* \return data size written in case of success, otherwise error code.
+*/
 ssize_t ec_slave_write_eeprom(ec_slave_t *slave, /**< EtherCAT slave */
 const uint8_t *data, /**< new EEPROM data */
 size_t size /**< size of data in bytes */
 )
 {
-uint16_t word_size, cat_type, cat_size;
+ec_eeprom_write_request_t request;
-const uint16_t *data_words, *next_header;
+const uint16_t *cat_header;
-uint16_t *new_data;
+uint16_t cat_type, cat_size;
+int ret;
-if (!slave->master->eeprom_write_enable) {
-EC_ERR("Writing EEPROMs not allowed! Enable via"
+if (slave->master->mode != EC_MASTER_MODE_IDLE) { // FIXME
-" eeprom_write_enable SysFS entry.\n");
-return -1;
-}
-if (slave->master->mode != EC_MASTER_MODE_IDLE) {
 EC_ERR("Writing EEPROMs only allowed in idle mode!\n");
-return -1;
+return -EBUSY;
 }
-if (slave->new_eeprom_data) {
-EC_ERR("Slave %i already has a pending EEPROM write operation!\n",
-slave->ring_position);
-return -1;
-}
-// coarse check of the data
 if (size % 2) {
-EC_ERR("EEPROM size is odd! Dropping.\n");
+EC_ERR("EEPROM data size is odd! Dropping.\n");
-return -1;
+return -EINVAL;
 }
-data_words = (const uint16_t *) data;
+// init EEPROM write request
-word_size = size / 2;
+INIT_LIST_HEAD(&request.list);
+request.slave = slave;
-if (word_size < 0x0041) {
+request.words = (const uint16_t *) data;
+request.offset = 0;
+request.size = size / 2;
+if (request.size < 0x0041) {
 EC_ERR("EEPROM data too short! Dropping.\n");
-return -1;
+return -EINVAL;
 }
-next_header = data_words + 0x0040;
+cat_header = request.words + EC_FIRST_EEPROM_CATEGORY_OFFSET;
-cat_type = EC_READ_U16(next_header);
+cat_type = EC_READ_U16(cat_header);
-while (cat_type != 0xFFFF) {
+while (cat_type != 0xFFFF) { // cycle through categories
-cat_type = EC_READ_U16(next_header);
+if (cat_header + 1 > request.words + request.size) {
-cat_size = EC_READ_U16(next_header + 1);
+EC_ERR("EEPROM data corrupted! Dropping.\n");
-if ((next_header + cat_size + 2) - data_words >= word_size) {
+return -EINVAL;
-EC_ERR("EEPROM data seems to be corrupted! Dropping.\n");
+}
-return -1;
+cat_size = EC_READ_U16(cat_header + 1);
-}
+if (cat_header + cat_size + 2 > request.words + request.size) {
-next_header += cat_size + 2;
+EC_ERR("EEPROM data corrupted! Dropping.\n");
-cat_type = EC_READ_U16(next_header);
+return -EINVAL;
 }
+cat_header += cat_size + 2;
-// data ok!
+cat_type = EC_READ_U16(cat_header);
+}
-if (!(new_data = (uint16_t *) kmalloc(word_size * 2, GFP_KERNEL))) {
-EC_ERR("Unable to allocate memory for new EEPROM data!\n");
+// EEPROM data ok. schedule writing.
-return -1;
+if ((ret = ec_slave_schedule_eeprom_writing(&request)))
-}
+return ret; // error code
-memcpy(new_data, data, size);
+return size; // success
-slave->new_eeprom_size = word_size;
+}
-slave->new_eeprom_data = new_data;
+/*****************************************************************************/
-EC_INFO("EEPROM writing scheduled for slave %i, %i words.\n",
-slave->ring_position, word_size);
+/**
-return 0;
+* Writes the Secondary slave address (alias) to the slave's EEPROM.
-}
+* \return data size written in case of success, otherwise error code.
+*/
+ssize_t ec_slave_write_alias(ec_slave_t *slave, /**< EtherCAT slave */
+const uint8_t *data, /**< alias string */
+size_t size /**< size of data in bytes */
+)
+{
+ec_eeprom_write_request_t request;
+char *remainder;
+uint16_t alias, word;
+int ret;
+if (slave->master->mode != EC_MASTER_MODE_IDLE) { // FIXME
+EC_ERR("Writing EEPROMs only allowed in idle mode!\n");
+return -EBUSY;
+}
+alias = simple_strtoul(data, &remainder, 0);
+if (remainder == (char *) data || (*remainder && *remainder != '\n')) {
+EC_ERR("Invalid alias value! Dropping.\n");
+return -EINVAL;
+}
+// correct endianess
+EC_WRITE_U16(&word, alias);
+// init EEPROM write request
+INIT_LIST_HEAD(&request.list);
+request.slave = slave;
+request.words = &word;
+request.offset = 0x0004;
+request.size = 1;
+if ((ret = ec_slave_schedule_eeprom_writing(&request)))
+return ret; // error code
+slave->sii_alias = alias; // FIXME: do this in state machine
+return size; // success
+}
 /*****************************************************************************/
 /**
 Formats attribute data for SysFS read access.
 else {
 memcpy(buffer, slave->eeprom_data, slave->eeprom_size);
 return slave->eeprom_size;
 }
 }
+}
+else if (attr == &attr_alias) {
+return sprintf(buffer, "%u\n", slave->sii_alias);
 }
 return 0;
 }
 EC_INFO("Accepted new state %s for slave %i.\n",
 state, slave->ring_position);
 return size;
 }
 else if (attr == &attr_eeprom) {
-if (!ec_slave_write_eeprom(slave, buffer, size))
+return ec_slave_write_eeprom(slave, buffer, size);
-return size;
+}
-}
+else if (attr == &attr_alias) {
+return ec_slave_write_alias(slave, buffer, size);
-return -EINVAL;
+}
-}
+return -EIO;
-/*****************************************************************************/
+}
-/**
+/*****************************************************************************/
-Calculates the size of a sync manager by evaluating PDO sizes.
-\return sync manager size
+/**
 */
-uint16_t ec_slave_calc_sync_size(const ec_slave_t *slave,
+ec_sync_t *ec_slave_get_pdo_sync(
-/**< EtherCAT slave */
+ec_slave_t *slave, /**< EtherCAT slave */
-const ec_sii_sync_t *sync
+ec_direction_t dir /**< input or output */
-/**< sync manager */
-)
-{
-ec_sii_pdo_t *pdo;
-ec_sii_pdo_entry_t *pdo_entry;
-unsigned int bit_size, byte_size;
-if (sync->length) return sync->length;
-if (sync->est_length) return sync->est_length;
-bit_size = 0;
-list_for_each_entry(pdo, &slave->sii_pdos, list) {
-if (pdo->sync_index != sync->index) continue;
-list_for_each_entry(pdo_entry, &pdo->entries, list) {
-bit_size += pdo_entry->bit_length;
-}
-}
-if (bit_size % 8) // round up to full bytes
-byte_size = bit_size / 8 + 1;
-else
-byte_size = bit_size / 8;
-return byte_size;
-}
-/*****************************************************************************/
-/**
-Initializes a sync manager configuration page with EEPROM data.
-The referenced memory (\a data) must be at least EC_SYNC_SIZE bytes.
-*/
-void ec_slave_sync_config(const ec_slave_t *slave, /**< EtherCAT slave */
-const ec_sii_sync_t *sync, /**< sync manager */
-uint8_t *data /**> configuration memory */
 )
 {
-size_t sync_size;
+unsigned int sync_index;
-sync_size = ec_slave_calc_sync_size(slave, sync);
+if (dir != EC_DIR_INPUT && dir != EC_DIR_OUTPUT) {
+EC_ERR("Invalid direction!\n");
-if (slave->master->debug_level) {
+return NULL;
-EC_DBG("Slave %3i, SM %i: Addr 0x%04X, Size %3i, Ctrl 0x%02X, En %i\n",
+}
-slave->ring_position, sync->index, sync->physical_start_address,
-sync_size, sync->control_register, sync->enable);
+sync_index = (unsigned int) dir;
-}
+if (slave->sii_mailbox_protocols) sync_index += 2;
-EC_WRITE_U16(data,     sync->physical_start_address);
+if (sync_index >= slave->sii_sync_count)
-EC_WRITE_U16(data + 2, sync_size);
+return NULL;
-EC_WRITE_U8 (data + 4, sync->control_register);
-EC_WRITE_U8 (data + 5, 0x00); // status byte (read only)
+return &slave->sii_syncs[sync_index];
-EC_WRITE_U16(data + 6, sync->enable ? 0x0001 : 0x0000); // enable
-}
-/*****************************************************************************/
-/**
-Initializes an FMMU configuration page.
-The referenced memory (\a data) must be at least EC_FMMU_SIZE bytes.
-*/
-void ec_slave_fmmu_config(const ec_slave_t *slave, /**< EtherCAT slave */
-const ec_fmmu_t *fmmu, /**< FMMU */
-uint8_t *data /**> configuration memory */
-)
-{
-size_t sync_size;
-sync_size = ec_slave_calc_sync_size(slave, fmmu->sync);
-if (slave->master->debug_level) {
-EC_DBG("Slave %3i, FMMU %2i:"
-" LogAddr 0x%08X, Size %3i, PhysAddr 0x%04X, Dir %s\n",
-slave->ring_position, fmmu->index, fmmu->logical_start_address,
-sync_size, fmmu->sync->physical_start_address,
-((fmmu->sync->control_register & 0x04) ? "out" : "in"));
-}
-EC_WRITE_U32(data,      fmmu->logical_start_address);
-EC_WRITE_U16(data + 4,  sync_size); // size of fmmu
-EC_WRITE_U8 (data + 6,  0x00); // logical start bit
-EC_WRITE_U8 (data + 7,  0x07); // logical end bit
-EC_WRITE_U16(data + 8,  fmmu->sync->physical_start_address);
-EC_WRITE_U8 (data + 10, 0x00); // physical start bit
-EC_WRITE_U8 (data + 11, ((fmmu->sync->control_register & 0x04)
-? 0x02 : 0x01));
-EC_WRITE_U16(data + 12, 0x0001); // enable
-EC_WRITE_U16(data + 14, 0x0000); // reserved
-}
-/*****************************************************************************/
-/**
-\return non-zero if slave is a bus coupler
-*/
-int ec_slave_is_coupler(const ec_slave_t *slave /**< EtherCAT slave */)
-{
-// TODO: Better bus coupler criterion
-return slave->sii_vendor_id == 0x00000002
-&& slave->sii_product_code == 0x044C2C52;
-}
-/*****************************************************************************/
-/**
-\return non-zero if slave is a bus coupler
-*/
-int ec_slave_has_subbus(const ec_slave_t *slave /**< EtherCAT slave */)
-{
-return slave->sii_vendor_id == 0x00000002
-&& slave->sii_product_code == 0x04602c22;
 }
 /*****************************************************************************/
 /**
 uint32_t product_code /**< product code */
 )
 {
 if (vendor_id != slave->sii_vendor_id ||
 product_code != slave->sii_product_code) {
-EC_ERR("Invalid slave type at position %i - Requested: 0x%08X 0x%08X,"
+EC_ERR("Invalid slave type at position %i:\n", slave->ring_position);
-" found: 0x%08X 0x%08X\".\n", slave->ring_position, vendor_id,
+EC_ERR("  Requested: 0x%08X 0x%08X\n", vendor_id, product_code);
-product_code, slave->sii_vendor_id, slave->sii_product_code);
+EC_ERR("      Found: 0x%08X 0x%08X\n",
+slave->sii_vendor_id, slave->sii_product_code);
 return -1;
 }
 return 0;
 }
 return ec_slave_conf_sdo(slave, sdo_index, sdo_subindex, data, 4);
 }
 /*****************************************************************************/
-/**
+void ecrt_slave_pdo_mapping_clear(
-\return 0 in case of success, else < 0
+ec_slave_t *slave, /**< EtherCAT slave */
-\ingroup RealtimeInterface
+ec_direction_t dir /**< output/input */
-*/
+)
+{
-int ecrt_slave_pdo_size(ec_slave_t *slave, /**< EtherCAT slave */
+ec_sync_t *sync;
-uint16_t pdo_index, /**< PDO index */
-uint8_t pdo_subindex, /**< PDO subindex */
+if (!(slave->sii_mailbox_protocols & EC_MBOX_COE)) {
-size_t size /**< new PDO size */
+EC_ERR("Slave %i does not support CoE!\n", slave->ring_position);
-)
+return;
-{
+}
-EC_WARN("ecrt_slave_pdo_size() currently not available.\n");
-return -1;
+if (!(sync = ec_slave_get_pdo_sync(slave, dir)))
+return;
-#if 0
-unsigned int i, j, field_counter;
+ec_sync_clear_pdos(sync);
-const ec_sii_sync_t *sync;
+}
-const ec_pdo_t *pdo;
-ec_varsize_t *var;
+/*****************************************************************************/
-if (!slave->type) {
+int ecrt_slave_pdo_mapping_add(
-EC_ERR("Slave %i has no type information!\n", slave->ring_position);
+ec_slave_t *slave, /**< EtherCAT slave */
+ec_direction_t dir, /**< input/output */
+uint16_t pdo_index /**< Index of PDO mapping list */)
+{
+ec_pdo_t *pdo;
+ec_sync_t *sync;
+unsigned int not_found = 1;
+if (!(slave->sii_mailbox_protocols & EC_MBOX_COE)) {
+EC_ERR("Slave %u does not support CoE!\n", slave->ring_position);
 return -1;
 }
-field_counter = 0;
+// does the slave provide the PDO list?
-for (i = 0; (sync = slave->type->sync_managers[i]); i++) {
+list_for_each_entry(pdo, &slave->sii_pdos, list) {
-for (j = 0; (field = sync->fields[j]); j++) {
+if (pdo->index == pdo_index) {
-if (!strcmp(field->name, field_name)) {
+not_found = 0;
-if (field_counter++ == field_index) {
+break;
-// is the size of this field variable?
+}
-if (field->size) {
+}
-EC_ERR("Field \"%s\"[%i] of slave %i has no variable"
-" size!\n", field->name, field_index,
+if (not_found) {
-slave->ring_position);
+EC_ERR("Slave %u does not provide PDO 0x%04X!\n",
-return -1;
+slave->ring_position, pdo_index);
-}
+return -1;
-// does a size specification already exist?
+}
-list_for_each_entry(var, &slave->varsize_fields, list) {
-if (var->field == field) {
+// check direction
-EC_WARN("Resizing field \"%s\"[%i] of slave %i.\n",
+if ((pdo->type == EC_TX_PDO && dir == EC_DIR_OUTPUT) ||
-field->name, field_index,
+(pdo->type == EC_RX_PDO && dir == EC_DIR_INPUT)) {
-slave->ring_position);
+EC_ERR("Invalid direction for PDO 0x%04X.\n", pdo_index);
-var->size = size;
+return -1;
-return 0;
+}
-}
-}
-// create a new size specification...
+if (!(sync = ec_slave_get_pdo_sync(slave, dir))) {
-if (!(var = kmalloc(sizeof(ec_varsize_t), GFP_KERNEL))) {
+EC_ERR("Failed to obtain sync manager for PDO mapping of slave %u!\n",
-EC_ERR("Failed to allocate memory for varsize_t!\n");
+slave->ring_position);
 return -1;
 }
-var->field = field;
-var->size = size;
+return ec_sync_add_pdo(sync, pdo);
-list_add_tail(&var->list, &slave->varsize_fields);
+}
-return 0;
-}
+/*****************************************************************************/
-}
-}
+int ecrt_slave_pdo_mapping(ec_slave_t *slave, /**< EtherCAT slave */
-}
+ec_direction_t dir, /**< input/output */
+unsigned int num_args, /**< Number of following arguments */
-EC_ERR("Slave %i (\"%s %s\") has no field \"%s\"[%i]!\n",
+... /**< PDO indices to map */
-slave->ring_position, slave->type->vendor_name,
+)
-slave->type->product_name, field_name, field_index);
+{
-return -1;
+va_list ap;
-#endif
-}
+ecrt_slave_pdo_mapping_clear(slave, dir);
+va_start(ap, num_args);
+for (; num_args; num_args--) {
+if (ecrt_slave_pdo_mapping_add(
+slave, dir, (uint16_t) va_arg(ap, int))) {
+return -1;
+}
+}
+va_end(ap);
+return 0;
+}
 /*****************************************************************************/
 /** \cond */
 EXPORT_SYMBOL(ecrt_slave_conf_sdo8);
 EXPORT_SYMBOL(ecrt_slave_conf_sdo16);
 EXPORT_SYMBOL(ecrt_slave_conf_sdo32);
-EXPORT_SYMBOL(ecrt_slave_pdo_size);
+EXPORT_SYMBOL(ecrt_slave_pdo_mapping_clear);
+EXPORT_SYMBOL(ecrt_slave_pdo_mapping_add);
+EXPORT_SYMBOL(ecrt_slave_pdo_mapping);
 /** \endcond */
 /*****************************************************************************/

branch	stable-1.3
changeset 1744	7bc131b92039
parent 1739	5fcbd29151d2
child 1746	72e7507b3f1b