bkinnightskytw
/
ethercat
mirror of https://gitlab.com/bkinnightskytw/ethercat.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

merge -c1618 branches/1.4-foe: Improved FoE.

This commit is contained in:
Florian Pose 2009-01-26 13:09:27 +00:00
parent 7a703ecb05
commit 8d45915fc4
11 changed files with 167 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
master/cdev.c
View File

@ -2429,6 +2429,11 @@ int ec_cdev_ioctl_slave_foe_read(
up(&master->master_sem);
if (master->debug_level) {
EC_DBG("Scheduled FoE read request on slave %u.\n",
request.slave->ring_position);
}
// wait for processing through FSM
if (wait_event_interruptible(master->foe_queue,
request.req.state != EC_INT_REQUEST_QUEUED)) {
@ -2447,11 +2452,12 @@ int ec_cdev_ioctl_slave_foe_read(
// wait until master FSM has finished processing
wait_event(master->foe_queue, request.req.state != EC_REQUEST_BUSY);
data.abort_code = request.req.abort_code;
data.result = request.req.result;
data.error_code = request.req.error_code;
if (master->debug_level) {
EC_DBG("%d bytes read via FoE (abort_code = 0x%x).\n",
request.req.data_size, request.req.abort_code);
EC_DBG("Read %d bytes via FoE (result = 0x%x).\n",
request.req.data_size, request.req.result);
}
if (request.req.state != EC_REQUEST_SUCCESS) {
@ -2476,7 +2482,12 @@ int ec_cdev_ioctl_slave_foe_read(
retval = -EFAULT;
}
if (master->debug_level)
EC_DBG("FoE read request finished on slave %u.\n",
request.slave->ring_position);
ec_foe_request_clear(&request.req);
return retval;
}
@ -2551,7 +2562,8 @@ int ec_cdev_ioctl_slave_foe_write(
// wait until master FSM has finished processing
wait_event(master->foe_queue, request.req.state != EC_REQUEST_BUSY);
data.abort_code = request.req.abort_code;
data.result = request.req.result;
data.error_code = request.req.error_code;
retval = request.req.state == EC_REQUEST_SUCCESS ? 0 : -EIO;

2
master/foe.h
View File

@ -38,7 +38,7 @@ typedef enum {
FOE_PROT_ERROR = 5,
FOE_NODATA_ERROR = 6,
FOE_PACKETNO_ERROR = 7,
FOE_OPMODE_ERROR = 8,
FOE_OPCODE_ERROR = 8,
FOE_TIMEOUT_ERROR = 9,
FOE_SEND_RX_DATA_ERROR = 10,
FOE_RX_DATA_ACK_ERROR = 11,

8
master/foe_request.c
View File

@ -41,6 +41,7 @@
#include <linux/jiffies.h>
#include "foe_request.h"
#include "foe.h"
/*****************************************************************************/
@ -68,7 +69,8 @@ void ec_foe_request_init(
req->issue_timeout = 0; // no timeout
req->response_timeout = EC_FOE_REQUEST_RESPONSE_TIMEOUT;
req->state = EC_INT_REQUEST_INIT;
req->abort_code = 0x00000000;
req->result = FOE_BUSY;
req->error_code = 0x00000000;
}
/*****************************************************************************/
@ -184,7 +186,7 @@ void ec_foe_request_read(ec_foe_request_t *req)
{
req->dir = EC_DIR_INPUT;
req->state = EC_INT_REQUEST_QUEUED;
req->abort_code = 0x00000000;
req->result = FOE_BUSY;
req->jiffies_start = jiffies;
}
@ -194,7 +196,7 @@ void ec_foe_request_write(ec_foe_request_t *req)
{
req->dir = EC_DIR_OUTPUT;
req->state = EC_INT_REQUEST_QUEUED;
req->abort_code = 0x00000000;
req->result = FOE_BUSY;
req->jiffies_start = jiffies;
}

5
master/foe_request.h
View File

@ -1,6 +1,6 @@
/******************************************************************************
*
* $Id:$
* $Id$
*
* Copyright (C) 2008 Olav Zarges, imc Meßsysteme GmbH
*
@ -68,7 +68,8 @@ typedef struct {
unsigned long jiffies_sent; /**< Jiffies, when the upload/download
request was sent. */
uint8_t *file_name; /**< Pointer to the filename. */
uint32_t abort_code; /**< FoE request abort code. Zero on success. */
uint32_t result; /**< FoE request abort code. Zero on success. */
uint32_t error_code; /**< Error code from an FoE Error Request. */
} ec_foe_request_t;
/*****************************************************************************/

101
master/fsm_foe.c
View File

@ -1,6 +1,6 @@
/******************************************************************************
*
* $Id:$
* $Id$
*
* Copyright (C) 2008 Olav Zarges, imc Meßsysteme GmbH
*
@ -52,6 +52,8 @@
#define EC_MBOX_TYPE_FILEACCESS 0x04
#define myDEBUG
/*****************************************************************************/
int ec_foe_prepare_data_send( ec_fsm_foe_t * );
@ -188,18 +190,18 @@ void ec_fsm_foe_end(ec_fsm_foe_t *fsm /**< finite state machine */)
// uint8_t Counter:4
#define EC_FOE_HEADER_SIZE 6
// uint8_t OpMode
// uint8_t OpCode
// uint8_t reserved
// uint32_t PacketNo, Password, ErrorCode
enum {
EC_FOE_OPMODE_RRQ = 1,
EC_FOE_OPMODE_WRQ = 2,
EC_FOE_OPMODE_DATA = 3,
EC_FOE_OPMODE_ACK = 4,
EC_FOE_OPMODE_ERR = 5,
EC_FOE_OPMODE_BUSY = 6
} ec_foe_opmode_t;
EC_FOE_OPCODE_RRQ = 1,
EC_FOE_OPCODE_WRQ = 2,
EC_FOE_OPCODE_DATA = 3,
EC_FOE_OPCODE_ACK = 4,
EC_FOE_OPCODE_ERR = 5,
EC_FOE_OPCODE_BUSY = 6
} ec_foe_opcode_t;
/*****************************************************************************/
/**
@ -224,7 +226,7 @@ int ec_foe_prepare_data_send( ec_fsm_foe_t *fsm ) {
EC_MBOX_TYPE_FILEACCESS, current_size + EC_FOE_HEADER_SIZE)))
return -1;
EC_WRITE_U8 ( data, EC_FOE_OPMODE_DATA ); // OpMode = DataBlock req.
EC_WRITE_U8 ( data, EC_FOE_OPCODE_DATA ); // OpCode = DataBlock req.
EC_WRITE_U32( data + 2, fsm->tx_packet_no ); // PacketNo, Password
memcpy(data + EC_FOE_HEADER_SIZE, fsm->tx_buffer + fsm->tx_buffer_offset, current_size);
@ -254,7 +256,7 @@ int ec_foe_prepare_wrq_send( ec_fsm_foe_t *fsm ) {
EC_MBOX_TYPE_FILEACCESS, current_size + EC_FOE_HEADER_SIZE)))
return -1;
EC_WRITE_U16( data, EC_FOE_OPMODE_WRQ); // fsm write request
EC_WRITE_U16( data, EC_FOE_OPCODE_WRQ); // fsm write request
EC_WRITE_U32( data + 2, fsm->tx_packet_no );
memcpy(data + EC_FOE_HEADER_SIZE, fsm->tx_filename, current_size);
@ -375,7 +377,7 @@ void ec_fsm_foe_state_ack_read( ec_fsm_foe_t *fsm ) {
ec_datagram_t *datagram = fsm->datagram;
ec_slave_t *slave = fsm->slave;
uint8_t *data, mbox_prot;
uint16_t opMode;
uint8_t opCode;
size_t rec_size;
#ifdef myDEBUG
@ -408,9 +410,9 @@ void ec_fsm_foe_state_ack_read( ec_fsm_foe_t *fsm ) {
return;
}
opMode = EC_READ_U16(data);
opCode = EC_READ_U8(data);
if ( opMode == EC_FOE_OPMODE_BUSY ) {
if (opCode == EC_FOE_OPCODE_BUSY) {
// slave ist noch nicht bereit
if (ec_foe_prepare_data_send(fsm)) {
ec_foe_set_tx_error(fsm, FOE_PROT_ERROR);
@ -421,7 +423,7 @@ void ec_fsm_foe_state_ack_read( ec_fsm_foe_t *fsm ) {
return;
}
if ( opMode == EC_FOE_OPMODE_ACK ) {
if (opCode == EC_FOE_OPCODE_ACK) {
fsm->tx_packet_no++;
fsm->tx_buffer_offset += fsm->tx_current_size;
@ -530,11 +532,15 @@ int ec_foe_prepare_rrq_send( ec_fsm_foe_t *fsm ) {
EC_MBOX_TYPE_FILEACCESS, current_size + EC_FOE_HEADER_SIZE)))
return -1;
EC_WRITE_U16( data, EC_FOE_OPMODE_RRQ); // fsm read request
EC_WRITE_U32( data + 2, 0 );
EC_WRITE_U16(data, EC_FOE_OPCODE_RRQ); // fsm read request
EC_WRITE_U32(data + 2, 0x00000000); // no passwd
memcpy(data + EC_FOE_HEADER_SIZE, fsm->rx_filename, current_size);
if (fsm->slave->master->debug_level) {
EC_DBG("FoE Read Request:\n");
ec_print_data(data, current_size + EC_FOE_HEADER_SIZE);
}
return 0;
}
@ -548,7 +554,7 @@ int ec_foe_prepare_send_ack( ec_fsm_foe_t *foe ) {
EC_MBOX_TYPE_FILEACCESS, EC_FOE_HEADER_SIZE)))
return -1;
EC_WRITE_U16( data, EC_FOE_OPMODE_ACK);
EC_WRITE_U16( data, EC_FOE_OPCODE_ACK);
EC_WRITE_U32( data + 2, foe->rx_expected_packet_no );
return 0;
@ -698,7 +704,7 @@ void ec_fsm_foe_state_data_check ( ec_fsm_foe_t *fsm ) {
void ec_fsm_foe_state_data_read ( ec_fsm_foe_t *fsm ) {
size_t rec_size;
uint8_t *data, opMode, packet_no, mbox_prot;
uint8_t *data, opCode, packet_no, mbox_prot;
ec_datagram_t *datagram = fsm->datagram;
ec_slave_t *slave = fsm->slave;
@ -706,6 +712,7 @@ void ec_fsm_foe_state_data_read ( ec_fsm_foe_t *fsm ) {
#ifdef myDEBUG
printk("ec_fsm_foe_state_data_read()\n");
#endif
if (datagram->state != EC_DATAGRAM_RECEIVED) {
ec_foe_set_rx_error(fsm, FOE_RECEIVE_ERROR);
EC_ERR("Failed to receive FoE DATA READ datagram for"
@ -733,37 +740,59 @@ void ec_fsm_foe_state_data_read ( ec_fsm_foe_t *fsm ) {
return;
}
opMode = EC_READ_U16(data);
opCode = EC_READ_U8(data);
if (opMode == EC_FOE_OPMODE_BUSY) {
if (opCode == EC_FOE_OPCODE_BUSY) {
if (ec_foe_prepare_send_ack(fsm)) {
ec_foe_set_rx_error(fsm, FOE_PROT_ERROR);
}
return;
}
if (opMode != EC_FOE_OPMODE_DATA) {
ec_foe_set_rx_error(fsm, FOE_OPMODE_ERROR);
if (opCode == EC_FOE_OPCODE_ERR) {
fsm->request->error_code = EC_READ_U32(data + 2);
EC_ERR("Received FoE Error Request (code %08x) on slave %u.\n",
fsm->request->error_code, slave->ring_position);
if (rec_size > 6) {
uint8_t text[1024];
strncpy(text, data + 6, min(rec_size - 6, sizeof(text)));
EC_ERR("FoE Error Text: %s\n", text);
}
ec_foe_set_rx_error(fsm, FOE_OPCODE_ERROR);
return;
}
if (opCode != EC_FOE_OPCODE_DATA) {
EC_ERR("Received OPCODE %x, expected %x on slave %u.\n",
opCode, EC_FOE_OPCODE_DATA, slave->ring_position);
fsm->request->error_code = 0x00000000;
ec_foe_set_rx_error(fsm, FOE_OPCODE_ERROR);
return;
}
packet_no = EC_READ_U16(data + 2);
if (packet_no != fsm->rx_expected_packet_no) {
EC_ERR("Received unexpected packet number on slave %u.\n",
slave->ring_position);
ec_foe_set_rx_error(fsm, FOE_PACKETNO_ERROR);
return;
}
rec_size -= EC_FOE_HEADER_SIZE;
if ( fsm->rx_buffer_size >= fsm->rx_buffer_offset + rec_size ) {
memcpy ( fsm->rx_buffer + fsm->rx_buffer_offset, data + EC_FOE_HEADER_SIZE, rec_size );
if (fsm->rx_buffer_size >= fsm->rx_buffer_offset + rec_size) {
memcpy(fsm->rx_buffer + fsm->rx_buffer_offset,
data + EC_FOE_HEADER_SIZE, rec_size);
fsm->rx_buffer_offset += rec_size;
}
fsm->rx_last_packet = (rec_size + EC_MBOX_HEADER_SIZE + EC_FOE_HEADER_SIZE != fsm->slave->sii.rx_mailbox_size);
fsm->rx_last_packet =
(rec_size + EC_MBOX_HEADER_SIZE + EC_FOE_HEADER_SIZE
!= fsm->slave->sii.rx_mailbox_size);
if (fsm->rx_last_packet ||
slave->sii.rx_mailbox_size - EC_MBOX_HEADER_SIZE - EC_FOE_HEADER_SIZE + fsm->rx_buffer_offset <= fsm->rx_buffer_size) {
(slave->sii.rx_mailbox_size - EC_MBOX_HEADER_SIZE
- EC_FOE_HEADER_SIZE + fsm->rx_buffer_offset) <= fsm->rx_buffer_size) {
// either it was the last packet or a new packet will fit into the delivered buffer
#ifdef myDEBUG
printk ("last_packet=true\n");
@ -776,8 +805,8 @@ void ec_fsm_foe_state_data_read ( ec_fsm_foe_t *fsm ) {
fsm->state = ec_fsm_foe_state_sent_ack;
}
else {
// no more data fits into the deliverd buffer
// ... wait for new read request (an den Treiber)
// no more data fits into the delivered buffer
// ... wait for new read request
printk ("ERROR: data doesn't fit in receive buffer\n");
printk (" rx_buffer_size = %d\n", fsm->rx_buffer_size);
printk (" rx_buffer_offset= %d\n", fsm->rx_buffer_offset);
@ -785,7 +814,7 @@ void ec_fsm_foe_state_data_read ( ec_fsm_foe_t *fsm ) {
printk (" rx_mailbox_size = %d\n", slave->sii.rx_mailbox_size);
printk (" rx_last_packet = %d\n", fsm->rx_last_packet);
// fsm->state = ec_fsm_state_wait_next_read;
fsm->request->abort_code = FOE_READY;
fsm->request->result = FOE_READY;
}
}
@ -834,17 +863,19 @@ void ec_fsm_foe_state_sent_ack( ec_fsm_foe_t *fsm ) {
/*****************************************************************************/
void ec_foe_set_tx_error( ec_fsm_foe_t *fsm, uint32_t errorcode ) {
void ec_foe_set_tx_error(ec_fsm_foe_t *fsm, uint32_t errorcode)
{
fsm->tx_errors++;
fsm->request->abort_code = errorcode;
fsm->request->result = errorcode;
fsm->state = ec_fsm_foe_error;
}
/*****************************************************************************/
void ec_foe_set_rx_error( ec_fsm_foe_t *fsm, uint32_t errorcode ) {
void ec_foe_set_rx_error(ec_fsm_foe_t *fsm, uint32_t errorcode)
{
fsm->rx_errors++;
fsm->request->abort_code = errorcode;
fsm->request->result = errorcode;
fsm->state = ec_fsm_foe_error;
}

22
master/fsm_master.c
View File

@ -493,17 +493,14 @@ int ec_fsm_master_action_process_foe(
request->req.state = EC_REQUEST_BUSY;
slave = request->slave;
EC_DBG("---- Master read command from queue ----\n");
// found pending FOE write operation. execute it!
if (master->debug_level)
EC_DBG("Writing FOE data to slave %u...\n",
request->slave->ring_position);
EC_DBG("Processing FoE request for slave %u.\n",
slave->ring_position);
fsm->foe_request = &request->req;
fsm->slave = slave;
fsm->state = ec_fsm_master_state_foe_request;
ec_fsm_foe_transfer(&fsm->fsm_foe, slave, &request->req);
//(&fsm->fsm_foe, request->slave, request->offset, request->words);
ec_fsm_foe_exec(&fsm->fsm_foe);
return 1;
}
@ -528,6 +525,10 @@ void ec_fsm_master_action_idle(
if (ec_fsm_master_action_process_sdo(fsm))
return;
// Check for pending FoE requests
if (ec_fsm_master_action_process_foe(fsm))
return;
// check, if slaves have an SDO dictionary to read out.
for (slave = master->slaves;
slave < master->slaves + master->slave_count;
@ -912,10 +913,11 @@ void ec_fsm_master_state_foe_request(
ec_foe_request_t *request = fsm->foe_request;
ec_slave_t *slave = fsm->slave;
if (ec_fsm_foe_exec(&fsm->fsm_foe)) return;
if (ec_fsm_foe_exec(&fsm->fsm_foe))
return;
if (!ec_fsm_foe_success(&fsm->fsm_foe)) {
EC_ERR("Failed to handle FOE request to slave %u.\n",
EC_ERR("Failed to handle FoE request to slave %u.\n",
slave->ring_position);
request->state = EC_INT_REQUEST_FAILURE;
wake_up(&master->foe_queue);
@ -923,10 +925,10 @@ void ec_fsm_master_state_foe_request(
return;
}
// finished writing FOE
// finished transferring FoE
if (master->debug_level)
EC_DBG("Finished writing %u words of FOE data to slave %u.\n",
request->data_size, slave->ring_position);
EC_DBG("Successfully transferred %u bytes of FoE data from/to"
" slave %u.\n", request->data_size, slave->ring_position);
request->state = EC_INT_REQUEST_SUCCESS;
wake_up(&master->foe_queue);

3
master/ioctl.h
View File

@ -334,7 +334,8 @@ typedef struct {
// outputs
uint32_t data_size;
uint32_t abort_code;
uint32_t result;
uint32_t error_code;
char file_name[32];
} ec_ioctl_slave_foe_t;

15
tool/CommandFoeRead.cpp
View File

@ -9,6 +9,7 @@
using namespace std;
#include "CommandFoeRead.h"
#include "foe.h"
/*****************************************************************************/
@ -82,7 +83,19 @@ void CommandFoeRead::execute(MasterDevice &m, const StringVector &args)
m.readFoe(&data);
} catch (MasterDeviceException &e) {
delete [] data.buffer;
throw e;
if (data.result) {
if (data.result == FOE_OPCODE_ERROR) {
err << "FoE read aborted with error code 0x"
<< setw(8) << setfill('0') << hex << data.error_code
<< ": " << errorText(data.error_code);
} else {
err << "Failed to write via FoE: "
<< resultText(data.result);
}
throwCommandException(err);
} else {
throw e;
}
}
// TODO --output-file

13
tool/CommandFoeWrite.cpp
View File

@ -12,6 +12,7 @@
using namespace std;
#include "CommandFoeWrite.h"
#include "foe.h"
/*****************************************************************************/
@ -119,9 +120,15 @@ void CommandFoeWrite::execute(MasterDevice &m, const StringVector &args)
} catch (MasterDeviceException &e) {
if (data.buffer_size)
delete [] data.buffer;
if (data.abort_code) {
err << "Failed to write via FoE: "
<< errorString(data.abort_code);
if (data.result) {
if (data.result == FOE_OPCODE_ERROR) {
err << "FoE write aborted with error code 0x"
<< setw(8) << setfill('0') << hex << data.error_code
<< ": " << errorText(data.error_code);
} else {
err << "Failed to write via FoE: "
<< resultText(data.result);
}
throwCommandException(err);
} else {
throw e;

40
tool/FoeCommand.cpp
View File

@ -16,9 +16,9 @@ FoeCommand::FoeCommand(const string &name, const string &briefDesc):
/****************************************************************************/
std::string FoeCommand::errorString(int abort_code)
std::string FoeCommand::resultText(int result)
{
switch (abort_code) {
switch (result) {
case FOE_BUSY:
return "FOE_BUSY";
case FOE_READY:
@ -35,8 +35,8 @@ std::string FoeCommand::errorString(int abort_code)
return "FOE_NODATA_ERROR";
case FOE_PACKETNO_ERROR:
return "FOE_PACKETNO_ERROR";
case FOE_OPMODE_ERROR:
return "FOE_OPMODE_ERROR";
case FOE_OPCODE_ERROR:
return "FOE_OPCODE_ERROR";
case FOE_TIMEOUT_ERROR:
return "FOE_TIMEOUT_ERROR";
case FOE_SEND_RX_DATA_ERROR:
@ -57,3 +57,35 @@ std::string FoeCommand::errorString(int abort_code)
}
/****************************************************************************/
std::string FoeCommand::errorText(int errorCode)
{
switch (errorCode) {
case 0x00008001:
return "Not found.";
case 0x00008002:
return "Access denied.";
case 0x00008003:
return "Disk full.";
case 0x00008004:
return "Illegal.";
case 0x00008005:
return "Packet number wrong.";
case 0x00008006:
return "Already exists.";
case 0x00008007:
return "No user.";
case 0x00008008:
return "Bootstrap only.";
case 0x00008009:
return "Not Bootstrap.";
case 0x0000800a:
return "No rights.";
case 0x0000800b:
return "Program Error.";
default:
return "Unknown error code";
}
}
/****************************************************************************/

3
tool/FoeCommand.h
View File

@ -18,7 +18,8 @@ class FoeCommand:
FoeCommand(const string &, const string &);
protected:
static std::string errorString(int);
static std::string resultText(int);
static std::string errorText(int);
};
/****************************************************************************/