Mercurial Mercurial > etherlabmaster / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
master/slave.c
branchstable-1.3
changeset 1749 696dd9f22777
parent 1746 72e7507b3f1b
child 1751 b6cfd85db58e
equal deleted inserted replaced
1748:a8740ac42365 1749:696dd9f22777 
   574             data += 8;
 
   574             data += 8;
 
   575         }
 
   575         }
 
   576 
   576 
   577         // if sync manager index is positive, the PDO is mapped by default
 
   577         // if sync manager index is positive, the PDO is mapped by default
 
   578         if (pdo->sync_index >= 0) {
 
   578         if (pdo->sync_index >= 0) {
 
       
   579             ec_sync_t *sync;
 
   579             ec_pdo_t *mapped_pdo;
 
   580             ec_pdo_t *mapped_pdo;
 
   580 
   581 
   581             if (pdo->sync_index >= slave->sii_sync_count) {
 
   582             if (pdo->sync_index >= slave->sii_sync_count) {
 
   582                 EC_ERR("Invalid SM index %i for PDO 0x%04X in slave %u.",
 
   583                 EC_ERR("Invalid SM index %i for PDO 0x%04X in slave %u.",
 
   583                         pdo->sync_index, pdo->index, slave->ring_position);
 
   584                         pdo->sync_index, pdo->index, slave->ring_position);
 
   584                 return -1;
 
   585                 return -1;
 
   585             }
 
   586             }
 
       
   587             sync = &slave->sii_syncs[pdo->sync_index];
 
   586 
   588 
   587             if (!(mapped_pdo = kmalloc(sizeof(ec_pdo_t), GFP_KERNEL))) {
 
   589             if (!(mapped_pdo = kmalloc(sizeof(ec_pdo_t), GFP_KERNEL))) {
 
   588                 EC_ERR("Failed to allocate PDO memory.\n");
 
   590                 EC_ERR("Failed to allocate PDO memory.\n");
 
   589                 return -1;
 
   591                 return -1;
 
   590             }
 
   592             }
 
   593                 EC_ERR("Failed to copy PDO.\n");
 
   595                 EC_ERR("Failed to copy PDO.\n");
 
   594                 kfree(mapped_pdo);
 
   596                 kfree(mapped_pdo);
 
   595                 return -1;
 
   597                 return -1;
 
   596             }
 
   598             }
 
   597 
   599 
   598             list_add_tail(&mapped_pdo->list,
 
   600             list_add_tail(&mapped_pdo->list, &sync->pdos);
 
   599                     &slave->sii_syncs[pdo->sync_index].pdos);
 
   601             sync->mapping_source = EC_SYNC_MAPPING_SII;
 
   600         }
 
   602         }
 
   601     }
 
   603     }
 
   602 
   604 
   603     return 0;
 
   605     return 0;
 
   604 }
 
   606 }
 
   696     ec_pdo_entry_t *pdo_entry;
 
   698     ec_pdo_entry_t *pdo_entry;
 
   697     int first, i;
 
   699     int first, i;
 
   698     ec_sdo_data_t *sdodata;
 
   700     ec_sdo_data_t *sdodata;
 
   699     char str[20];
 
   701     char str[20];
 
   700 
   702 
   701     off += sprintf(buffer + off, "\nName: ");
 
   703     off += sprintf(buffer + off, "Ring position: %i\n",
 
   702 
   704                    slave->ring_position);
 
   703     if (slave->sii_name)
 
       
   704         off += sprintf(buffer + off, "%s", slave->sii_name);
 
       
   705 
       
   706     off += sprintf(buffer + off, "\nVendor ID: 0x%08X\n",
 
       
   707                    slave->sii_vendor_id);
 
       
   708     off += sprintf(buffer + off, "Product code: 0x%08X\n\n",
 
       
   709                    slave->sii_product_code);
 
       
   710 
       
   711     off += sprintf(buffer + off, "State: ");
 
   705     off += sprintf(buffer + off, "State: ");
 
   712     off += ec_state_string(slave->current_state, buffer + off);
 
   706     off += ec_state_string(slave->current_state, buffer + off);
 
   713     off += sprintf(buffer + off, " (");
 
   707     off += sprintf(buffer + off, " (");
 
   714     off += ec_state_string(slave->requested_state, buffer + off);
 
   708     off += ec_state_string(slave->requested_state, buffer + off);
 
   715     off += sprintf(buffer + off, ")\nFlags: %s, %s\n",
 
   709     off += sprintf(buffer + off, ")\n");
 
       
   710     off += sprintf(buffer + off, "Flags: %s, %s\n\n",
 
   716             slave->online_state == EC_SLAVE_ONLINE ? "online" : "OFFLINE",
 
   711             slave->online_state == EC_SLAVE_ONLINE ? "online" : "OFFLINE",
 
   717             slave->error_flag ? "ERROR" : "ok");
 
   712             slave->error_flag ? "ERROR" : "ok");
 
   718     off += sprintf(buffer + off, "Ring position: %i\n",
 
       
   719                    slave->ring_position);
 
       
   720     off += sprintf(buffer + off, "Current consumption: %i mA\n\n",
 
       
   721                    slave->sii_current_on_ebus);
 
       
   722 
   713 
   723     off += sprintf(buffer + off, "Data link status:\n");
 
   714     off += sprintf(buffer + off, "Data link status:\n");
 
   724     for (i = 0; i < 4; i++) {
 
   715     for (i = 0; i < 4; i++) {
 
   725         off += sprintf(buffer + off, "  Port %i (", i);
 
   716         off += sprintf(buffer + off, "  Port %i (", i);
 
   726         switch (slave->sii_physical_layer[i]) {
 
   717         switch (slave->sii_physical_layer[i]) {
 
   740         off += sprintf(buffer + off, ") Link %s, Loop %s, %s\n",
 
   731         off += sprintf(buffer + off, ") Link %s, Loop %s, %s\n",
 
   741                        slave->dl_link[i] ? "up" : "down",
 
   732                        slave->dl_link[i] ? "up" : "down",
 
   742                        slave->dl_loop[i] ? "closed" : "open",
 
   733                        slave->dl_loop[i] ? "closed" : "open",
 
   743                        slave->dl_signal[i] ? "Signal detected" : "No signal");
 
   734                        slave->dl_signal[i] ? "Signal detected" : "No signal");
 
   744     }
 
   735     }
 
       
   736     off += sprintf(buffer + off, "\n");
 
       
   737 
       
   738     if (slave->sii_alias)
 
       
   739         off += sprintf(buffer + off, "Configured station alias:"
 
       
   740                        " 0x%04X (%i)\n\n", slave->sii_alias, slave->sii_alias);
 
       
   741 
       
   742     off += sprintf(buffer + off, "Vendor ID: 0x%08X (%u)\n",
 
       
   743                    slave->sii_vendor_id, slave->sii_vendor_id);
 
       
   744     off += sprintf(buffer + off, "Product code: 0x%08X (%u)\n",
 
       
   745                    slave->sii_product_code, slave->sii_product_code);
 
       
   746     off += sprintf(buffer + off, "Revision number: 0x%08X (%u)\n",
 
       
   747                    slave->sii_revision_number, slave->sii_revision_number);
 
       
   748     off += sprintf(buffer + off, "Serial number: 0x%08X (%u)\n\n",
 
       
   749                    slave->sii_serial_number, slave->sii_serial_number);
 
   745 
   750 
   746     if (slave->sii_mailbox_protocols) {
 
   751     if (slave->sii_mailbox_protocols) {
 
   747         off += sprintf(buffer + off, "\nMailboxes:\n");
 
   752         off += sprintf(buffer + off, "Mailboxes:\n");
 
   748         off += sprintf(buffer + off, "  RX mailbox: 0x%04X/%i,"
 
   753         off += sprintf(buffer + off, "  RX: 0x%04X/%u, TX: 0x%04X/%u\n",
 
   749                        " TX mailbox: 0x%04X/%i\n",
 
   754                 slave->sii_rx_mailbox_offset, slave->sii_rx_mailbox_size,
 
   750                        slave->sii_rx_mailbox_offset,
 
   755                 slave->sii_tx_mailbox_offset, slave->sii_tx_mailbox_size);
 
   751                        slave->sii_rx_mailbox_size,
 
       
   752                        slave->sii_tx_mailbox_offset,
 
       
   753                        slave->sii_tx_mailbox_size);
 
       
   754         off += sprintf(buffer + off, "  Supported protocols: ");
 
   756         off += sprintf(buffer + off, "  Supported protocols: ");
 
   755 
   757 
   756         first = 1;
 
   758         first = 1;
 
   757         if (slave->sii_mailbox_protocols & EC_MBOX_AOE) {
 
   759         if (slave->sii_mailbox_protocols & EC_MBOX_AOE) {
 
   758             off += sprintf(buffer + off, "AoE");
 
   760             off += sprintf(buffer + off, "AoE");
 
   780         }
 
   782         }
 
   781         if (slave->sii_mailbox_protocols & EC_MBOX_VOE) {
 
   783         if (slave->sii_mailbox_protocols & EC_MBOX_VOE) {
 
   782             if (!first) off += sprintf(buffer + off, ", ");
 
   784             if (!first) off += sprintf(buffer + off, ", ");
 
   783             off += sprintf(buffer + off, "VoE");
 
   785             off += sprintf(buffer + off, "VoE");
 
   784         }
 
   786         }
 
       
   787         off += sprintf(buffer + off, "\n\n");
 
       
   788     }
 
       
   789 
       
   790     off += sprintf(buffer + off, "Current consumption: %i mA\n\n",
 
       
   791             slave->sii_current_on_ebus);
 
       
   792 
       
   793     if (slave->sii_group || slave->sii_image || slave->sii_order
 
       
   794             || slave->sii_name) {
 
       
   795         off += sprintf(buffer + off, "General:\n");
 
       
   796 
       
   797         if (slave->sii_group)
 
       
   798             off += sprintf(buffer + off, "  Group: %s\n", slave->sii_group);
 
       
   799         if (slave->sii_image)
 
       
   800             off += sprintf(buffer + off, "  Image: %s\n", slave->sii_image);
 
       
   801         if (slave->sii_order)
 
       
   802             off += sprintf(buffer + off, "  Order number: %s\n",
 
       
   803                     slave->sii_order);
 
       
   804         if (slave->sii_name)
 
       
   805             off += sprintf(buffer + off, "  Name: %s\n", slave->sii_name);
 
   785         off += sprintf(buffer + off, "\n");
 
   806         off += sprintf(buffer + off, "\n");
 
   786     }
 
   807     }
 
   787 
   808 
   788     if (slave->sii_alias || slave->sii_group
 
   809     if (slave->sii_sync_count) {
 
   789         || slave->sii_image || slave->sii_order)
 
   810         off += sprintf(buffer + off, "Sync managers / PDO mapping:\n");
 
   790         off += sprintf(buffer + off, "\nSII data:\n");
 
   811 
   791 
   812         for (i = 0; i < slave->sii_sync_count; i++) {
 
   792     if (slave->sii_alias)
 
   813             sync = &slave->sii_syncs[i];
 
   793         off += sprintf(buffer + off, "  Configured station alias:"
 
   814             off += sprintf(buffer + off,
 
   794                        " 0x%04X (%i)\n", slave->sii_alias, slave->sii_alias);
 
   815                     "  SM%u: addr 0x%04X, size %i, control 0x%02X, %s\n",
 
   795     if (slave->sii_group)
 
   816                     sync->index, sync->physical_start_address,
 
   796         off += sprintf(buffer + off, "  Group: %s\n", slave->sii_group);
 
   817                     ec_sync_size(sync), sync->control_register,
 
   797     if (slave->sii_image)
 
   818                     sync->enable ? "enable" : "disable");
 
   798         off += sprintf(buffer + off, "  Image: %s\n", slave->sii_image);
 
   819 
   799     if (slave->sii_order)
 
   820             if (list_empty(&sync->pdos)) {
 
   800         off += sprintf(buffer + off, "  Order number: %s\n", slave->sii_order);
 
   821                 off += sprintf(buffer + off, "    No PDOs mapped.\n");
 
   801 
   822             } else if (sync->mapping_source != EC_SYNC_MAPPING_NONE) {
 
   802     if (slave->sii_sync_count)
 
   823                 off += sprintf(buffer + off,
 
   803         off += sprintf(buffer + off, "\nSync managers / PDO mapping:\n");
 
   824                         "    PDO mapping information from %s.\n",
 
   804 
   825                         sync->mapping_source == EC_SYNC_MAPPING_SII
 
   805     for (i = 0; i < slave->sii_sync_count; i++) {
 
   826                         ? "SII" : "CoE");
 
   806         sync = &slave->sii_syncs[i];
 
   827             }
 
   807         off += sprintf(buffer + off,
 
   828 
   808                 "  SM%u: addr 0x%04X, size %i, control 0x%02X, %s\n",
 
   829             list_for_each_entry(pdo, &sync->pdos, list) {
 
   809                 sync->index, sync->physical_start_address,
 
   830                 off += sprintf(buffer + off, "    %s 0x%04X \"%s\"\n",
 
   810                 ec_sync_size(sync), sync->control_register,
 
   831                         pdo->type == EC_RX_PDO ? "RxPdo" : "TxPdo",
 
   811                 sync->enable ? "enable" : "disable");
 
   832                         pdo->index, pdo->name ? pdo->name : "???");
 
   812 
   833 
   813         if (list_empty(&sync->pdos))
 
   834                 list_for_each_entry(pdo_entry, &pdo->entries, list) {
 
   814             off += sprintf(buffer + off, "    No PDOs mapped.\n");
 
   835                     off += sprintf(buffer + off,
 
   815 
   836                             "      0x%04X:%X \"%s\", %i bit\n",
 
   816         list_for_each_entry(pdo, &sync->pdos, list) {
 
   837                             pdo_entry->index, pdo_entry->subindex,
 
   817             off += sprintf(buffer + off, "    %s 0x%04X \"%s\"\n",
 
   838                             pdo_entry->name ? pdo_entry->name : "???",
 
       
   839                             pdo_entry->bit_length);
 
       
   840                 }
 
       
   841             }
 
       
   842         }
 
       
   843         off += sprintf(buffer + off, "\n");
 
       
   844     }
 
       
   845 
       
   846     // type-cast to avoid warnings on some compilers
 
       
   847     if (!list_empty((struct list_head *) &slave->sii_pdos)) {
 
       
   848         off += sprintf(buffer + off, "Available PDOs from SII:\n");
 
       
   849 
       
   850         list_for_each_entry(pdo, &slave->sii_pdos, list) {
 
       
   851             off += sprintf(buffer + off, "  %s 0x%04X \"%s\"",
 
   818                     pdo->type == EC_RX_PDO ? "RxPdo" : "TxPdo",
 
   852                     pdo->type == EC_RX_PDO ? "RxPdo" : "TxPdo",
 
   819                     pdo->index, pdo->name ? pdo->name : "???");
 
   853                     pdo->index, pdo->name ? pdo->name : "???");
 
       
   854             if (pdo->sync_index >= 0)
 
       
   855                 off += sprintf(buffer + off, ", default mapping: SM%u.\n",
 
       
   856                         pdo->sync_index);
 
       
   857             else
 
       
   858                 off += sprintf(buffer + off, ", no default mapping.\n");
 
   820 
   859 
   821             list_for_each_entry(pdo_entry, &pdo->entries, list) {
 
   860             list_for_each_entry(pdo_entry, &pdo->entries, list) {
 
   822                 off += sprintf(buffer + off,
 
   861                 off += sprintf(buffer + off, "    0x%04X:%X \"%s\", %i bit\n",
 
   823                         "      0x%04X:%X \"%s\", %i bit\n",
 
       
   824                         pdo_entry->index, pdo_entry->subindex,
 
   862                         pdo_entry->index, pdo_entry->subindex,
 
   825                         pdo_entry->name ? pdo_entry->name : "???",
 
   863                         pdo_entry->name ? pdo_entry->name : "???",
 
   826                         pdo_entry->bit_length);
 
   864                         pdo_entry->bit_length);
 
   827             }
 
   865             }
 
   828         }
 
   866         }
 
       
   867         off += sprintf(buffer + off, "\n");
 
   829     }
 
   868     }
 
   830 
   869 
   831     // type-cast to avoid warnings on some compilers
 
   870     // type-cast to avoid warnings on some compilers
 
   832     if (!list_empty((struct list_head *) &slave->sii_pdos))
 
   871     if (!list_empty((struct list_head *) &slave->sdo_confs)) {
 
   833         off += sprintf(buffer + off, "\nAvailable PDOs:\n");
 
   872         off += sprintf(buffer + off, "SDO configurations:\n");
 
   834 
   873 
   835     list_for_each_entry(pdo, &slave->sii_pdos, list) {
 
   874         list_for_each_entry(sdodata, &slave->sdo_confs, list) {
 
   836         off += sprintf(buffer + off, "  %s 0x%04X \"%s\"",
 
   875             switch (sdodata->size) {
 
   837                        pdo->type == EC_RX_PDO ? "RxPdo" : "TxPdo",
 
   876                 case 1: sprintf(str, "%i", EC_READ_U8(sdodata->data)); break;
 
   838                        pdo->index, pdo->name ? pdo->name : "???");
 
   877                 case 2: sprintf(str, "%i", EC_READ_U16(sdodata->data)); break;
 
   839         if (pdo->sync_index >= 0)
 
   878                 case 4: sprintf(str, "%i", EC_READ_U32(sdodata->data)); break;
 
   840             off += sprintf(buffer + off, ", default mapping: SM%u.\n",
 
   879                 default: sprintf(str, "(invalid size)"); break;
 
   841                     pdo->sync_index);
 
   880             }
 
   842         else
 
   881             off += sprintf(buffer + off, "  0x%04X:%-3i -> %s\n",
 
   843             off += sprintf(buffer + off, ", no default mapping.\n");
 
   882                     sdodata->index, sdodata->subindex, str);
 
   844 
   883         }
 
   845         list_for_each_entry(pdo_entry, &pdo->entries, list) {
 
   884         off += sprintf(buffer + off, "\n");
 
   846             off += sprintf(buffer + off, "    0x%04X:%X \"%s\", %i bit\n",
 
   885     }
 
   847                            pdo_entry->index, pdo_entry->subindex,
 
       
   848                            pdo_entry->name ? pdo_entry->name : "???",
 
       
   849                            pdo_entry->bit_length);
 
       
   850         }
 
       
   851     }
 
       
   852 
       
   853     // type-cast to avoid warnings on some compilers
 
       
   854     if (!list_empty((struct list_head *) &slave->sdo_confs))
 
       
   855         off += sprintf(buffer + off, "\nSDO configurations:\n");
 
       
   856 
       
   857     list_for_each_entry(sdodata, &slave->sdo_confs, list) {
 
       
   858         switch (sdodata->size) {
 
       
   859             case 1: sprintf(str, "%i", EC_READ_U8(sdodata->data)); break;
 
       
   860             case 2: sprintf(str, "%i", EC_READ_U16(sdodata->data)); break;
 
       
   861             case 4: sprintf(str, "%i", EC_READ_U32(sdodata->data)); break;
 
       
   862             default: sprintf(str, "(invalid size)"); break;
 
       
   863         }
 
       
   864         off += sprintf(buffer + off, "  0x%04X:%-3i -> %s\n",
 
       
   865                        sdodata->index, sdodata->subindex, str);
 
       
   866     }
 
       
   867 
       
   868     off += sprintf(buffer + off, "\n");
 
       
   869 
   886 
   870     return off;
 
   887     return off;
 
   871 }
 
   888 }
 
   872 
   889 
   873 /*****************************************************************************/
 
   890 /*****************************************************************************/
etherlabmaster