etherlabmaster: comparison master/fsm

equal deleted inserted replaced

-:024a3c6aa3f7
+:fa1c4fb0a8da
 ec_print_data(request->data, request->data_size);
 }
 if (!(slave->sii.mailbox_protocols & EC_MBOX_COE)) {
 EC_SLAVE_ERR(slave, "Slave does not support CoE!\n");
+request->errno = EPROTONOSUPPORT;
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (slave->configured_rx_mailbox_size <
 EC_MBOX_HEADER_SIZE + EC_COE_DOWN_REQ_HEADER_SIZE) {
 EC_SLAVE_ERR(slave, "Mailbox too small!\n");
+request->errno = EOVERFLOW;
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (request->data_size <= 4) { // use expedited transfer type
 data = ec_slave_mbox_prepare_send(slave, datagram, 0x03,
 EC_COE_DOWN_REQ_HEADER_SIZE);
 if (IS_ERR(data)) {
+request->errno = PTR_ERR(data);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 fsm->remaining = 0;
 }
 data = ec_slave_mbox_prepare_send(slave, datagram, 0x03,
 data_size);
 if (IS_ERR(data)) {
+request->errno = PTR_ERR(data);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 fsm->offset = 0;
 if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 return; // FIXME: check for response first?
 if (datagram->state != EC_DATAGRAM_RECEIVED) {
+fsm->request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Failed to receive CoE download"
 " request datagram: ");
 ec_datagram_print_state(datagram);
 return;
 #endif
 // no response; send request datagram again
 return;
 }
 }
+fsm->request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Reception of CoE download request"
 " for SDO 0x%04x:%x failed with timeout after %lu ms: ",
 fsm->request->index, fsm->request->subindex, diff_ms);
 ec_datagram_print_wc_error(datagram);
 if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 return;
 if (datagram->state != EC_DATAGRAM_RECEIVED) {
+fsm->request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Failed to receive CoE mailbox check"
 " datagram: ");
 ec_datagram_print_state(datagram);
 return;
 }
 if (datagram->working_counter != 1) {
+fsm->request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Reception of CoE mailbox check"
 " datagram failed: ");
 ec_datagram_print_wc_error(datagram);
 return;
 if (!ec_slave_mbox_check(datagram)) {
 unsigned long diff_ms =
 (datagram->jiffies_received - fsm->jiffies_start) * 1000 / HZ;
 if (diff_ms >= fsm->request->response_timeout) {
+fsm->request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Timeout after %lu ms while waiting"
 " for SDO 0x%04x:%x download response.\n", diff_ms,
 fsm->request->index, fsm->request->subindex);
 return;
 }
 data = ec_slave_mbox_prepare_send(slave, datagram, 0x03,
 data_size);
 if (IS_ERR(data)) {
+request->errno = PTR_ERR(data);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 EC_WRITE_U16(data, 0x2 << 12); // SDO request
 if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 return; // FIXME: request again?
 if (datagram->state != EC_DATAGRAM_RECEIVED) {
+request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Failed to receive CoE download"
 " response datagram: ");
 ec_datagram_print_state(datagram);
 return;
 }
 if (datagram->working_counter != 1) {
+request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Reception of CoE download response failed: ");
 ec_datagram_print_wc_error(datagram);
 return;
 }
 data = ec_slave_mbox_fetch(slave, datagram, &mbox_prot, &rec_size);
 if (IS_ERR(data)) {
+request->errno = PTR_ERR(data);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (mbox_prot != 0x03) { // CoE
+request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Received mailbox protocol 0x%02X as response.\n",
 mbox_prot);
 return;
 }
 EC_SLAVE_DBG(slave, 1, "Download response:\n");
 ec_print_data(data, rec_size);
 }
 if (rec_size < 6) {
+request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Received data are too small (%zu bytes):\n",
 rec_size);
 ec_print_data(data, rec_size);
 return;
 }
 if (EC_READ_U16(data) >> 12 == 0x2 && // SDO request
 EC_READ_U8 (data + 2) >> 5 == 0x4) { // abort SDO transfer request
 char subidxstr[10];
+request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 if (request->complete_access) {
 subidxstr[0] = 0x00;
 } else {
 sprintf(subidxstr, ":%02X", request->subindex);
 if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 return;
 if (datagram->state != EC_DATAGRAM_RECEIVED) {
+fsm->request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Failed to receive CoE mailbox check datagram: ");
 ec_datagram_print_state(datagram);
 return;
 }
 if (datagram->working_counter != 1) {
+fsm->request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Reception of CoE mailbox segment check"
 " datagram failed: ");
 ec_datagram_print_wc_error(datagram);
 return;
 if (!ec_slave_mbox_check(datagram)) {
 unsigned long diff_ms =
 (datagram->jiffies_received - fsm->jiffies_start) * 1000 / HZ;
 if (diff_ms >= fsm->request->response_timeout) {
+fsm->request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Timeout while waiting for SDO download"
 " segment response.\n");
 return;
 }
 if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 return; // FIXME: request again?
 if (datagram->state != EC_DATAGRAM_RECEIVED) {
+request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Failed to receive CoE download response"
 " datagram: ");
 ec_datagram_print_state(datagram);
 return;
 }
 if (datagram->working_counter != 1) {
+request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Reception of CoE download response failed: ");
 ec_datagram_print_wc_error(datagram);
 return;
 }
 data = ec_slave_mbox_fetch(slave, datagram, &mbox_prot, &rec_size);
 if (IS_ERR(data)) {
+request->errno = PTR_ERR(data);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (mbox_prot != 0x03) { // CoE
+request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Received mailbox protocol 0x%02X as response.\n",
 mbox_prot);
 return;
 }
 EC_SLAVE_DBG(slave, 1, "Download response:\n");
 ec_print_data(data, rec_size);
 }
 if (rec_size < 6) {
+request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Received data are too small (%zu bytes):\n",
 rec_size);
 ec_print_data(data, rec_size);
 return;
 }
 if (EC_READ_U16(data) >> 12 == 0x2 && // SDO request
 EC_READ_U8 (data + 2) >> 5 == 0x4) { // abort SDO transfer request
 char subidxstr[10];
+request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 if (request->complete_access) {
 subidxstr[0] = 0x00;
 } else {
 sprintf(subidxstr, ":%02X", request->subindex);
 if (((EC_READ_U8(data + 2) >> 4) & 0x01) != fsm->toggle) {
 EC_SLAVE_ERR(slave, "Invalid toggle received during"
 " segmented download:\n");
 ec_print_data(data, rec_size);
+request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (fsm->remaining) { // more segments to download
 EC_SLAVE_DBG(slave, 1, "Uploading SDO 0x%04X:%02X.\n",
 request->index, request->subindex);
 if (!(slave->sii.mailbox_protocols & EC_MBOX_COE)) {
 EC_SLAVE_ERR(slave, "Slave does not support CoE!\n");
+request->errno = EPROTONOSUPPORT;
 fsm->state = ec_fsm_coe_error;
 return;
 }
 data = ec_slave_mbox_prepare_send(slave, datagram, 0x03, 10);
 if (IS_ERR(data)) {
+request->errno = PTR_ERR(data);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 EC_WRITE_U16(data, 0x2 << 12); // SDO request
 if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 return; // FIXME: check for response first?
 if (datagram->state != EC_DATAGRAM_RECEIVED) {
+fsm->request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Failed to receive CoE upload request: ");
 ec_datagram_print_state(datagram);
 return;
 }
 #endif
 // no response; send request datagram again
 return;
 }
 }
+fsm->request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Reception of CoE upload request for"
 " SDO 0x%04x:%x failed with timeout after %lu ms: ",
 fsm->request->index, fsm->request->subindex, diff_ms);
 ec_datagram_print_wc_error(datagram);
 if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 return;
 if (datagram->state != EC_DATAGRAM_RECEIVED) {
+fsm->request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Failed to receive CoE mailbox check datagram: ");
 ec_datagram_print_state(datagram);
 return;
 }
 if (datagram->working_counter != 1) {
+fsm->request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Reception of CoE mailbox check"
 " datagram failed: ");
 ec_datagram_print_wc_error(datagram);
 return;
 if (!ec_slave_mbox_check(datagram)) {
 unsigned long diff_ms =
 (datagram->jiffies_received - fsm->jiffies_start) * 1000 / HZ;
 if (diff_ms >= fsm->request->response_timeout) {
+fsm->request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Timeout after %lu ms while waiting for"
 " SDO 0x%04x:%x upload response.\n", diff_ms,
 fsm->request->index, fsm->request->subindex);
 return;
 )
 {
 uint8_t *data =
 ec_slave_mbox_prepare_send(fsm->slave, fsm->datagram, 0x03, 10);
 if (IS_ERR(data)) {
+fsm->request->errno = PTR_ERR(data);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 EC_WRITE_U16(data, 0x2 << 12); // SDO request
 uint16_t rec_index;
 uint8_t *data, mbox_prot, rec_subindex;
 size_t rec_size, data_size;
 ec_sdo_request_t *request = fsm->request;
 unsigned int expedited, size_specified;
+int ret;
 if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 return; // FIXME: request again?
 if (datagram->state != EC_DATAGRAM_RECEIVED) {
+request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Failed to receive CoE upload response"
 " datagram: ");
 ec_datagram_print_state(datagram);
 return;
 }
 if (datagram->working_counter != 1) {
+request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Reception of CoE upload response failed: ");
 ec_datagram_print_wc_error(datagram);
 return;
 }
 data = ec_slave_mbox_fetch(slave, datagram, &mbox_prot, &rec_size);
 if (IS_ERR(data)) {
+request->errno = PTR_ERR(data);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (master->debug_level) {
 EC_SLAVE_DBG(slave, 1, "Upload response:\n");
 ec_print_data(data, rec_size);
 }
 if (mbox_prot != 0x03) { // CoE
+request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_WARN(slave, "Received mailbox protocol 0x%02X"
 " as response.\n", mbox_prot);
 return;
 }
 fsm->state = ec_fsm_coe_up_check;
 return;
 }
 if (rec_size < 6) {
+request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Received currupted SDO upload response"
 " (%zu bytes)!\n", rec_size);
 ec_print_data(data, rec_size);
 return;
 request->abort_code = EC_READ_U32(data + 6);
 ec_canopen_abort_msg(slave, request->abort_code);
 } else {
 EC_SLAVE_ERR(slave, "No abort message.\n");
 }
+request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (EC_READ_U16(data) >> 12 != 0x3 || // SDO response
 EC_READ_U8(data + 2) >> 5 != 0x2) { // upload response
 EC_SLAVE_ERR(slave, "Received unknown response while"
 " uploading SDO 0x%04X:%02X.\n",
 request->index, request->subindex);
 ec_print_data(data, rec_size);
+request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 return;
 }
 rec_index = EC_READ_U16(data + 3);
 } else {
 fsm->complete_size = 4;
 }
 if (rec_size < 6 + fsm->complete_size) {
+request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Received corrupted SDO expedited upload"
 " response (only %zu bytes)!\n", rec_size);
 ec_print_data(data, rec_size);
 return;
 }
-if (ec_sdo_request_copy_data(request, data + 6, fsm->complete_size)) {
+ret = ec_sdo_request_copy_data(request, data + 6, fsm->complete_size);
+if (ret) {
+request->errno = -ret;
 fsm->state = ec_fsm_coe_error;
 return;
 }
 } else { // normal
 if (rec_size < 10) {
+request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Received currupted SDO normal upload"
 " response (only %zu bytes)!\n", rec_size);
 ec_print_data(data, rec_size);
 return;
 data_size = rec_size - 10;
 fsm->complete_size = EC_READ_U32(data + 6);
 if (!fsm->complete_size) {
+request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "No complete size supplied!\n");
 ec_print_data(data, rec_size);
 return;
 }
-if (ec_sdo_request_alloc(request, fsm->complete_size)) {
+ret = ec_sdo_request_alloc(request, fsm->complete_size);
+if (ret) {
+request->errno = -ret;
 fsm->state = ec_fsm_coe_error;
 return;
 }
-if (ec_sdo_request_copy_data(request, data + 10, data_size)) {
+ret = ec_sdo_request_copy_data(request, data + 10, data_size);
+if (ret) {
+request->errno = -ret;
 fsm->state = ec_fsm_coe_error;
 return;
 }
 fsm->toggle = 0;
 if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 return; // FIXME: check for response first?
 if (datagram->state != EC_DATAGRAM_RECEIVED) {
+fsm->request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Failed to receive CoE upload segment"
 " request datagram: ");
 ec_datagram_print_state(datagram);
 return;
 }
 if (datagram->working_counter != 1) {
+fsm->request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Reception of CoE upload segment"
 " request failed: ");
 ec_datagram_print_wc_error(datagram);
 return;
 if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 return;
 if (datagram->state != EC_DATAGRAM_RECEIVED) {
+fsm->request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Failed to receive CoE mailbox check"
 " datagram: ");
 ec_datagram_print_state(datagram);
 return;
 }
 if (datagram->working_counter != 1) {
+fsm->request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Reception of CoE mailbox check datagram"
 " failed: ");
 ec_datagram_print_wc_error(datagram);
 return;
 if (!ec_slave_mbox_check(datagram)) {
 unsigned long diff_ms =
 (datagram->jiffies_received - fsm->jiffies_start) * 1000 / HZ;
 if (diff_ms >= fsm->request->response_timeout) {
+fsm->request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Timeout while waiting for SDO upload"
 " segment response.\n");
 return;
 }
 if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 return; // FIXME: request again?
 if (datagram->state != EC_DATAGRAM_RECEIVED) {
+request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Failed to receive CoE upload segment"
 " response datagram: ");
 ec_datagram_print_state(datagram);
 return;
 }
 if (datagram->working_counter != 1) {
+request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 EC_SLAVE_ERR(slave, "Reception of CoE upload segment"
 " response failed: ");
 ec_datagram_print_wc_error(datagram);
 return;
 }
 data = ec_slave_mbox_fetch(slave, datagram, &mbox_prot, &rec_size);
 if (IS_ERR(data)) {
+request->errno = PTR_ERR(data);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (master->debug_level) {
 }
 if (mbox_prot != 0x03) { // CoE
 EC_SLAVE_ERR(slave, "Received mailbox protocol 0x%02X as response.\n",
 mbox_prot);
+request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (ec_fsm_coe_check_emergency(fsm, data, rec_size)) {
 if (rec_size < 10) {
 EC_SLAVE_ERR(slave, "Received currupted SDO upload"
 " segment response!\n");
 ec_print_data(data, rec_size);
+request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (EC_READ_U16(data) >> 12 == 0x2 && // SDO request
 EC_READ_U8 (data + 2) >> 5 == 0x4) { // abort SDO transfer request
 EC_SLAVE_ERR(slave, "SDO upload 0x%04X:%02X aborted.\n",
 request->index, request->subindex);
 request->abort_code = EC_READ_U32(data + 6);
 ec_canopen_abort_msg(slave, request->abort_code);
+request->errno = EIO;
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (EC_READ_U16(data) >> 12 != 0x3 || // SDO response
 if (request->data_size + data_size > fsm->complete_size) {
 EC_SLAVE_ERR(slave, "SDO upload 0x%04X:%02X failed: Fragment"
 " exceeding complete size!\n",
 request->index, request->subindex);
+request->errno = EOVERFLOW;
 fsm->state = ec_fsm_coe_error;
 return;
 }
 memcpy(request->data + request->data_size, data + 3, data_size);

changeset 1948	fa1c4fb0a8da
parent 1931	831f2d34664c
child 2041	f5b31f46c38f
child 2196	6b481c7b3b34