etherlabmaster: comparison master/fsm

equal deleted inserted replaced

-:f46bec1b5f21
+:f0047c6226c0
 int ec_fsm_soe_success(ec_fsm_soe_t *fsm /**< Finite state machine */)
 {
 return fsm->state == ec_fsm_soe_end;
 }
+/*****************************************************************************/
+/** Output information about a failed SoE transfer.
+*/
+void ec_fsm_soe_print_error(ec_fsm_soe_t *fsm /**< Finite state machine */)
+{
+ec_soe_request_t *request = fsm->request;
+EC_ERR("");
+if (request->dir == EC_DIR_OUTPUT) {
+printk("Writing");
+} else {
+printk("Reading");
+}
+printk("IDN 0x%04X failed on slave %u.\n",
+request->idn, fsm->slave->ring_position);
+}
 /******************************************************************************
 * SoE read state machine
 *****************************************************************************/
 /** SoE state: READ START.
 if (master->debug_level)
 EC_DBG("Reading IDN 0x%04X from slave %u.\n",
 request->idn, slave->ring_position);
 if (!(slave->sii.mailbox_protocols & EC_MBOX_SOE)) {
-EC_ERR("Slave %u does not support SoE!\n", slave->ring_position);
+EC_ERR("Slave does not support SoE!\n");
 fsm->state = ec_fsm_soe_error;
+ec_fsm_soe_print_error(fsm);
 return;
 }
 data = ec_slave_mbox_prepare_send(slave, datagram, EC_MBOX_TYPE_SOE,
 EC_SOE_READ_REQUEST_SIZE);
 if (IS_ERR(data)) {
 fsm->state = ec_fsm_soe_error;
+ec_fsm_soe_print_error(fsm);
 return;
 }
 EC_WRITE_U8(data, EC_SOE_OPCODE_READ_REQUEST);
 EC_WRITE_U8(data + 1, 1 << 6); // request value
 if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 return; // FIXME: check for response first?
 if (datagram->state != EC_DATAGRAM_RECEIVED) {
 fsm->state = ec_fsm_soe_error;
-EC_ERR("Failed to receive SoE read request for slave %u: ",
+EC_ERR("Failed to receive SoE read request: ");
-slave->ring_position);
 ec_datagram_print_state(datagram);
+ec_fsm_soe_print_error(fsm);
 return;
 }
 diff_ms = (jiffies - fsm->request->jiffies_sent) * 1000 / HZ;
 // no response; send request datagram again
 return;
 }
 }
 fsm->state = ec_fsm_soe_error;
-EC_ERR("Reception of SoE read request for IDN 0x%04x failed"
+EC_ERR("Reception of SoE read request failed after %u ms: ",
-" after %u ms on slave %u: ",
+(u32) diff_ms);
-fsm->request->idn, (u32) diff_ms,
-fsm->slave->ring_position);
 ec_datagram_print_wc_error(datagram);
+ec_fsm_soe_print_error(fsm);
 return;
 }
 fsm->jiffies_start = datagram->jiffies_sent;
 ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
 if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 return;
 if (datagram->state != EC_DATAGRAM_RECEIVED) {
 fsm->state = ec_fsm_soe_error;
-EC_ERR("Failed to receive SoE mailbox check datagram from slave %u: ",
+EC_ERR("Failed to receive SoE mailbox check datagram: ");
-slave->ring_position);
 ec_datagram_print_state(datagram);
+ec_fsm_soe_print_error(fsm);
 return;
 }
 if (datagram->working_counter != 1) {
 fsm->state = ec_fsm_soe_error;
-EC_ERR("Reception of SoE mailbox check datagram failed on slave %u: ",
+EC_ERR("Reception of SoE mailbox check datagram failed: ");
-slave->ring_position);
 ec_datagram_print_wc_error(datagram);
+ec_fsm_soe_print_error(fsm);
 return;
 }
 if (!ec_slave_mbox_check(datagram)) {
 unsigned long diff_ms =
 (datagram->jiffies_received - fsm->jiffies_start) * 1000 / HZ;
 if (diff_ms >= EC_SOE_RESPONSE_TIMEOUT) {
 fsm->state = ec_fsm_soe_error;
-EC_ERR("Timeout after %u ms while waiting for IDN 0x%04x"
+EC_ERR("Timeout after %u ms while waiting for read response.\n",
-" read response on slave %u.\n", (u32) diff_ms,
+(u32) diff_ms);
-fsm->request->idn, slave->ring_position);
+ec_fsm_soe_print_error(fsm);
 return;
 }
 ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
 fsm->retries = EC_FSM_RETRIES;
 if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 return; // FIXME: request again?
 if (datagram->state != EC_DATAGRAM_RECEIVED) {
 fsm->state = ec_fsm_soe_error;
-EC_ERR("Failed to receive SoE read response datagram for"
+EC_ERR("Failed to receive SoE read response datagram: ");
-" slave %u: ", slave->ring_position);
 ec_datagram_print_state(datagram);
+ec_fsm_soe_print_error(fsm);
 return;
 }
 if (datagram->working_counter != 1) {
 fsm->state = ec_fsm_soe_error;
-EC_ERR("Reception of SoE read response failed on slave %u: ",
+EC_ERR("Reception of SoE read response failed: ");
-slave->ring_position);
 ec_datagram_print_wc_error(datagram);
+ec_fsm_soe_print_error(fsm);
 return;
 }
 data = ec_slave_mbox_fetch(slave, datagram, &mbox_prot, &rec_size);
 if (IS_ERR(data)) {
 fsm->state = ec_fsm_soe_error;
+ec_fsm_soe_print_error(fsm);
 return;
 }
 if (master->debug_level) {
 EC_DBG("SCC read response:\n");
 ec_print_data(data, rec_size);
 }
 if (mbox_prot != EC_MBOX_TYPE_SOE) {
 fsm->state = ec_fsm_soe_error;
-EC_WARN("Received mailbox protocol 0x%02X as response.\n", mbox_prot);
+EC_ERR("Received mailbox protocol 0x%02X as response.\n", mbox_prot);
+ec_fsm_soe_print_error(fsm);
 return;
 }
 if (rec_size < EC_SOE_READ_RESPONSE_SIZE) {
 fsm->state = ec_fsm_soe_error;
-EC_ERR("Received currupted SoE read response (%zu bytes)!\n",
+EC_ERR("Received currupted SoE read response"
-rec_size);
+" (%zu bytes)!\n", rec_size);
 ec_print_data(data, rec_size);
+ec_fsm_soe_print_error(fsm);
 return;
 }
 header = EC_READ_U8(data);
 opcode = header & 0x7;
 error_flag = (header >> 4) & 1;
 if (opcode != EC_SOE_OPCODE_READ_RESPONSE) {
 EC_ERR("Received no read response (opcode %x).\n", opcode);
 ec_print_data(data, rec_size);
+ec_fsm_soe_print_error(fsm);
 fsm->state = ec_fsm_soe_error;
 return;
 }
 if (error_flag) {
 req->error_code = EC_READ_U16(data + rec_size - 2);
 EC_ERR("Received error response:\n");
 ec_print_soe_error(req->error_code);
+ec_fsm_soe_print_error(fsm);
 fsm->state = ec_fsm_soe_error;
 return;
 } else {
 req->error_code = 0x0000;
 }
 value_included = (EC_READ_U8(data + 1) >> 6) & 1;
 if (!value_included) {
 EC_ERR("No value included!\n");
+ec_fsm_soe_print_error(fsm);
 fsm->state = ec_fsm_soe_error;
 return;
 }
 data_size = rec_size - EC_SOE_READ_RESPONSE_SIZE;
 if (ec_soe_request_append_data(req,
 data + EC_SOE_READ_RESPONSE_SIZE, data_size)) {
 fsm->state = ec_fsm_soe_error;
+ec_fsm_soe_print_error(fsm);
 return;
 }
 if (incomplete) {
 if (master->debug_level) {
 header_size = EC_MBOX_HEADER_SIZE + EC_SOE_WRITE_REQUEST_SIZE;
 if (slave->configured_rx_mailbox_size <= header_size) {
 EC_ERR("Mailbox size (%u) too small for SoE write.\n",
 slave->configured_rx_mailbox_size);
 fsm->state = ec_fsm_soe_error;
+ec_fsm_soe_print_error(fsm);
 return;
 }
 remaining_size = req->data_size - fsm->offset;
 max_fragment_size = slave->configured_rx_mailbox_size - header_size;
 data = ec_slave_mbox_prepare_send(slave, datagram, EC_MBOX_TYPE_SOE,
 EC_SOE_WRITE_REQUEST_SIZE + fragment_size);
 if (IS_ERR(data)) {
 fsm->state = ec_fsm_soe_error;
+ec_fsm_soe_print_error(fsm);
 return;
 }
 EC_WRITE_U8(data, EC_SOE_OPCODE_WRITE_REQUEST | incomplete << 3);
 EC_WRITE_U8(data + 1, 1 << 6); // only value included
 if (master->debug_level)
 EC_DBG("Writing IDN 0x%04X (%zu byte) to slave %u.\n",
 req->idn, req->data_size, slave->ring_position);
 if (!(slave->sii.mailbox_protocols & EC_MBOX_SOE)) {
-EC_ERR("Slave %u does not support SoE!\n", slave->ring_position);
+EC_ERR("Slave does not support SoE!\n");
 fsm->state = ec_fsm_soe_error;
+ec_fsm_soe_print_error(fsm);
 return;
 }
 fsm->offset = 0;
 ec_fsm_soe_write_next_fragment(fsm);
 if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 return; // FIXME: check for response first?
 if (datagram->state != EC_DATAGRAM_RECEIVED) {
 fsm->state = ec_fsm_soe_error;
-EC_ERR("Failed to receive SoE write request for slave %u: ",
+EC_ERR("Failed to receive SoE write request: ");
-slave->ring_position);
 ec_datagram_print_state(datagram);
+ec_fsm_soe_print_error(fsm);
 return;
 }
 diff_ms = (jiffies - fsm->request->jiffies_sent) * 1000 / HZ;
 // no response; send request datagram again
 return;
 }
 }
 fsm->state = ec_fsm_soe_error;
-EC_ERR("Reception of SoE write request for IDN 0x%04x failed"
+EC_ERR("Reception of SoE write request failed after %u ms: ",
-" after %u ms on slave %u: ",
+(u32) diff_ms);
-fsm->request->idn, (u32) diff_ms,
-fsm->slave->ring_position);
 ec_datagram_print_wc_error(datagram);
+ec_fsm_soe_print_error(fsm);
 return;
 }
 fsm->jiffies_start = datagram->jiffies_sent;
 if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 return;
 if (datagram->state != EC_DATAGRAM_RECEIVED) {
 fsm->state = ec_fsm_soe_error;
-EC_ERR("Failed to receive SoE write request datagram from slave %u: ",
+EC_ERR("Failed to receive SoE write request datagram: ");
-slave->ring_position);
 ec_datagram_print_state(datagram);
+ec_fsm_soe_print_error(fsm);
 return;
 }
 if (datagram->working_counter != 1) {
 fsm->state = ec_fsm_soe_error;
-EC_ERR("Reception of SoE write request datagram failed on slave %u: ",
+EC_ERR("Reception of SoE write request datagram: ");
-slave->ring_position);
 ec_datagram_print_wc_error(datagram);
+ec_fsm_soe_print_error(fsm);
 return;
 }
 if (fsm->offset < req->data_size) {
 ec_fsm_soe_write_next_fragment(fsm);
 if (!ec_slave_mbox_check(datagram)) {
 unsigned long diff_ms =
 (datagram->jiffies_received - fsm->jiffies_start) * 1000 / HZ;
 if (diff_ms >= EC_SOE_RESPONSE_TIMEOUT) {
 fsm->state = ec_fsm_soe_error;
-EC_ERR("Timeout after %u ms while waiting for IDN 0x%04x"
+EC_ERR("Timeout after %u ms while waiting"
-" write response on slave %u.\n", (u32) diff_ms,
+" for write response.\n", (u32) diff_ms);
-fsm->request->idn, slave->ring_position);
+ec_fsm_soe_print_error(fsm);
 return;
 }
 ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
 fsm->retries = EC_FSM_RETRIES;
 if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 return; // FIXME: request again?
 if (datagram->state != EC_DATAGRAM_RECEIVED) {
 fsm->state = ec_fsm_soe_error;
-EC_ERR("Failed to receive SoE write response datagram for"
+EC_ERR("Failed to receive SoE write response datagram: ");
-" slave %u: ", slave->ring_position);
 ec_datagram_print_state(datagram);
+ec_fsm_soe_print_error(fsm);
 return;
 }
 if (datagram->working_counter != 1) {
 fsm->state = ec_fsm_soe_error;
-EC_ERR("Reception of SoE write response failed on slave %u: ",
+EC_ERR("Reception of SoE write response failed: ");
-slave->ring_position);
 ec_datagram_print_wc_error(datagram);
+ec_fsm_soe_print_error(fsm);
 return;
 }
 data = ec_slave_mbox_fetch(slave, datagram, &mbox_prot, &rec_size);
 if (IS_ERR(data)) {
 fsm->state = ec_fsm_soe_error;
+ec_fsm_soe_print_error(fsm);
 return;
 }
 if (master->debug_level) {
 EC_DBG("SCC write response:\n");
 ec_print_data(data, rec_size);
 }
 if (mbox_prot != EC_MBOX_TYPE_SOE) {
 fsm->state = ec_fsm_soe_error;
-EC_WARN("Received mailbox protocol 0x%02X as response.\n", mbox_prot);
+EC_ERR("Received mailbox protocol 0x%02X as response.\n", mbox_prot);
+ec_fsm_soe_print_error(fsm);
 return;
 }
 if (rec_size < EC_SOE_WRITE_RESPONSE_SIZE) {
 fsm->state = ec_fsm_soe_error;
 EC_ERR("Received currupted SoE write response (%zu bytes)!\n",
 rec_size);
 ec_print_data(data, rec_size);
+ec_fsm_soe_print_error(fsm);
 return;
 }
 opcode = EC_READ_U8(data) & 0x7;
 if (opcode != EC_SOE_OPCODE_WRITE_RESPONSE) {
 EC_ERR("Received no write response (opcode %x).\n", opcode);
 ec_print_data(data, rec_size);
+ec_fsm_soe_print_error(fsm);
 fsm->state = ec_fsm_soe_error;
 return;
 }
 idn = EC_READ_U16(data + 2);
 if (idn != req->idn) {
 EC_ERR("Received response for wrong IDN 0x%04x.\n", idn);
 ec_print_data(data, rec_size);
+ec_fsm_soe_print_error(fsm);
 fsm->state = ec_fsm_soe_error;
 return;
 }
 error_flag = (EC_READ_U8(data) >> 4) & 1;
 req->error_code = EC_READ_U16(data + EC_SOE_WRITE_RESPONSE_SIZE);
 EC_ERR("Received error response:\n");
 ec_print_soe_error(req->error_code);
 }
 ec_print_data(data, rec_size);
+ec_fsm_soe_print_error(fsm);
 fsm->state = ec_fsm_soe_error;
 return;
 } else {
 req->error_code = 0x0000;
 }

changeset 1881	f0047c6226c0
parent 1877	7b77000f9764
child 1882	8ae8cc56d910