etherlabmaster: comparison master/fsm

equal deleted inserted replaced

-:ea38efeeb7b3
+:6aa393418fb3
 {}
 };
 /*****************************************************************************/
-/**
+/** Outputs an SDO abort message.
-Outputs an SDO abort message.
+*/
-*/
+void ec_canopen_abort_msg(const ec_slave_t *slave, uint32_t abort_code)
-void ec_canopen_abort_msg(uint32_t abort_code)
 {
 const ec_code_msg_t *abort_msg;
 for (abort_msg = sdo_abort_messages; abort_msg->code; abort_msg++) {
 if (abort_msg->code == abort_code) {
-EC_ERR("SDO abort message 0x%08X: \"%s\".\n",
+EC_SLAVE_ERR(slave, "SDO abort message 0x%08X: \"%s\".\n",
 abort_msg->code, abort_msg->message);
 return;
 }
 }
-EC_ERR("Unknown SDO abort code 0x%08X.\n", abort_code);
+EC_SLAVE_ERR(slave, "Unknown SDO abort code 0x%08X.\n", abort_code);
 }
 /*****************************************************************************/
 /**
 {
 if (size < 2 || ((EC_READ_U16(data) >> 12) & 0x0F) != 0x01)
 return 0;
 if (size < 10) {
-EC_WARN("Received incomplete CoE Emergency request from slave %u:\n",
+EC_SLAVE_WARN(fsm->slave, "Received incomplete CoE Emergency"
-fsm->slave->ring_position);
+" request:\n");
 ec_print_data(data, size);
 return 1;
 }
-EC_INFO("CoE Emergency Request received from slave %u:\n",
+EC_SLAVE_WARN(fsm->slave, "CoE Emergency Request received:\n"
-fsm->slave->ring_position);
+"Error code 0x%04X, Error register 0x%02X, data:\n",
-EC_INFO("Error code 0x%04X, Error register 0x%02X, data:\n",
 EC_READ_U16(data + 2), EC_READ_U8(data + 4));
 ec_print_data(data + 5, 5);
 return 1;
 }
 ec_datagram_t *datagram = fsm->datagram;
 ec_slave_t *slave = fsm->slave;
 uint8_t *data;
 if (!(slave->sii.mailbox_protocols & EC_MBOX_COE)) {
-EC_ERR("Slave %u does not support CoE!\n", slave->ring_position);
+EC_SLAVE_ERR(slave, "Slave does not support CoE!\n");
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (slave->sii.has_general && !slave->sii.coe_details.enable_sdo_info) {
-EC_ERR("Slave %u does not support SDO information service!\n",
+EC_SLAVE_ERR(slave, "Slave does not support"
-slave->ring_position);
+" SDO information service!\n");
 fsm->state = ec_fsm_coe_error;
 return;
 }
 data = ec_slave_mbox_prepare_send(slave, datagram, 0x03, 8);
 if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 return; // FIXME: request again?
 if (datagram->state != EC_DATAGRAM_RECEIVED) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Failed to receive CoE dictionary request datagram for"
+EC_SLAVE_ERR(slave, "Failed to receive CoE dictionary"
-" slave %u: ", slave->ring_position);
+" request datagram: ");
 ec_datagram_print_state(datagram);
 return;
 }
 if (datagram->working_counter != 1) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Reception of CoE dictionary request failed on slave %u: ",
+EC_SLAVE_ERR(slave, "Reception of CoE dictionary request failed: ");
-slave->ring_position);
 ec_datagram_print_wc_error(datagram);
 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_coe_error;
-EC_ERR("Failed to receive CoE mailbox check datagram for slave %u: ",
+EC_SLAVE_ERR(slave, "Failed to receive CoE mailbox check datagram: ");
-slave->ring_position);
 ec_datagram_print_state(datagram);
 return;
 }
 if (datagram->working_counter != 1) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Reception of CoE mailbox check datagram failed on slave %u: ",
+EC_SLAVE_ERR(slave,"Reception of CoE mailbox check"
-slave->ring_position);
+" 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 >= EC_FSM_COE_DICT_TIMEOUT) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Timeout while waiting for SDO dictionary list response "
+EC_SLAVE_ERR(slave, "Timeout while waiting for"
-"on slave %u.\n", slave->ring_position);
+" SDO dictionary list response.\n");
 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_coe_error;
-EC_ERR("Failed to receive CoE dictionary response datagram for"
+EC_SLAVE_ERR(slave, "Failed to receive CoE dictionary"
-" slave %u: ", slave->ring_position);
+" response datagram: ");
 ec_datagram_print_state(datagram);
 return;
 }
 if (datagram->working_counter != 1) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Reception of CoE dictionary response failed on slave %u: ",
+EC_SLAVE_ERR(slave, "Reception of CoE dictionary response failed: ");
-slave->ring_position);
 ec_datagram_print_wc_error(datagram);
 return;
 }
 data = ec_slave_mbox_fetch(slave, datagram, &mbox_prot, &rec_size);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (mbox_prot != 0x03) { // CoE
-EC_ERR("Received mailbox protocol 0x%02X as response.\n", mbox_prot);
+EC_SLAVE_ERR(slave, "Received mailbox protocol 0x%02X as response.\n",
+mbox_prot);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (ec_fsm_coe_check_emergency(fsm, data, rec_size)) {
 fsm->state = ec_fsm_coe_dict_check;
 return;
 }
 if (rec_size < 3) {
-EC_ERR("Received corrupted SDO dictionary response (size %zu).\n",
+EC_SLAVE_ERR(slave, "Received corrupted SDO dictionary response"
-rec_size);
+" (size %zu).\n", rec_size);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (EC_READ_U16(data) >> 12 == 0x8 && // SDO information
 (EC_READ_U8(data + 2) & 0x7F) == 0x07) { // error response
-EC_ERR("SDO information error response at slave %u!\n",
+EC_SLAVE_ERR(slave, "SDO information error response!\n");
-slave->ring_position);
 if (rec_size < 10) {
-EC_ERR("Incomplete SDO information error response:\n");
+EC_SLAVE_ERR(slave, "Incomplete SDO information"
+" error response:\n");
 ec_print_data(data, rec_size);
 } else {
-ec_canopen_abort_msg(EC_READ_U32(data + 6));
+ec_canopen_abort_msg(slave, EC_READ_U32(data + 6));
 }
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (EC_READ_U16(data) >> 12 != 0x8 || // SDO information
 (EC_READ_U8 (data + 2) & 0x7F) != 0x02) { // Get OD List response
 if (fsm->slave->master->debug_level) {
-EC_DBG("Invalid SDO list response at slave %u! Retrying...\n",
+EC_SLAVE_DBG(slave, 1, "Invalid SDO list response!"
-slave->ring_position);
+" Retrying...\n");
 ec_print_data(data, rec_size);
 }
 ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
 fsm->retries = EC_FSM_RETRIES;
 fsm->state = ec_fsm_coe_dict_check;
 return;
 }
 if (rec_size < 8 || rec_size % 2) {
-EC_ERR("Invalid data size %zu!\n", rec_size);
+EC_SLAVE_ERR(slave, "Invalid data size %zu!\n", rec_size);
 ec_print_data(data, rec_size);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 sdo_count = (rec_size - 8) / 2;
 for (i = 0; i < sdo_count; i++) {
 sdo_index = EC_READ_U16(data + 8 + i * 2);
 if (!sdo_index) {
-if (slave->master->debug_level)
+EC_SLAVE_DBG(slave, 1, "SDO dictionary contains index 0x0000.\n");
-EC_WARN("SDO dictionary of slave %u contains index 0x0000.\n",
-slave->ring_position);
 continue;
 }
 if (!(sdo = (ec_sdo_t *) kmalloc(sizeof(ec_sdo_t), GFP_KERNEL))) {
-EC_ERR("Failed to allocate memory for SDO!\n");
+EC_SLAVE_ERR(slave, "Failed to allocate memory for SDO!\n");
 fsm->state = ec_fsm_coe_error;
 return;
 }
 ec_sdo_init(sdo, slave, sdo_index);
 list_add_tail(&sdo->list, &slave->sdo_dictionary);
 }
 fragments_left = EC_READ_U16(data + 4);
-if (slave->master->debug_level && fragments_left) {
+if (fragments_left) {
-EC_DBG("SDO list fragments left: %u\n", fragments_left);
+EC_SLAVE_DBG(slave, 1, "SDO list fragments left: %u\n",
-}
+fragments_left);
+}
-if (EC_READ_U8(data + 2) & 0x80 || fragments_left) { // more messages waiting. check again.
+if (EC_READ_U8(data + 2) & 0x80 || fragments_left) {
+// more messages waiting. check again.
 fsm->jiffies_start = datagram->jiffies_sent;
 ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
 fsm->retries = EC_FSM_RETRIES;
 fsm->state = ec_fsm_coe_dict_check;
 return;
 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_coe_error;
-EC_ERR("Failed to receive CoE SDO description request datagram for"
+EC_SLAVE_ERR(slave, "Failed to receive CoE SDO"
-" slave %u: ", slave->ring_position);
+" description request datagram: ");
 ec_datagram_print_state(datagram);
 return;
 }
 if (datagram->working_counter != 1) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Reception of CoE SDO description"
+EC_SLAVE_ERR(slave, "Reception of CoE SDO description"
-" request failed on slave %u: ", slave->ring_position);
+" request failed: ");
 ec_datagram_print_wc_error(datagram);
 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_coe_error;
-EC_ERR("Failed to receive CoE mailbox check datagram from slave %u: ",
+EC_SLAVE_ERR(slave, "Failed to receive CoE mailbox check datagram: ");
-slave->ring_position);
 ec_datagram_print_state(datagram);
 return;
 }
 if (datagram->working_counter != 1) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Reception of CoE mailbox check"
+EC_SLAVE_ERR(slave, "Reception of CoE mailbox check"
-" datagram failed on slave %u: ", slave->ring_position);
+" 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 >= EC_FSM_COE_DICT_TIMEOUT) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Timeout while waiting for SDO 0x%04x object description "
+EC_SLAVE_ERR(slave, "Timeout while waiting for"
-"response on slave %u.\n", fsm->sdo->index,
+" SDO 0x%04x object description response.\n",
-slave->ring_position);
+fsm->sdo->index);
 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_coe_error;
-EC_ERR("Failed to receive CoE SDO description response datagram from"
+EC_SLAVE_ERR(slave, "Failed to receive CoE SDO description"
-" slave %u: ", slave->ring_position);
+" response datagram: ");
 ec_datagram_print_state(datagram);
 return;
 }
 if (datagram->working_counter != 1) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Reception of CoE SDO description"
+EC_SLAVE_ERR(slave, "Reception of CoE SDO description"
-" response failed on slave %u: ", slave->ring_position);
+" response failed: ");
 ec_datagram_print_wc_error(datagram);
 return;
 }
 data = ec_slave_mbox_fetch(slave, datagram, &mbox_prot, &rec_size);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (mbox_prot != 0x03) { // CoE
-EC_ERR("Received mailbox protocol 0x%02X as response.\n", mbox_prot);
+EC_SLAVE_ERR(slave, "Received mailbox protocol 0x%02X as response.\n",
+mbox_prot);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (ec_fsm_coe_check_emergency(fsm, data, rec_size)) {
 fsm->state = ec_fsm_coe_dict_desc_check;
 return;
 }
 if (rec_size < 3) {
-EC_ERR("Received corrupted SDO description response (size %zu).\n",
+EC_SLAVE_ERR(slave, "Received corrupted SDO description response"
-rec_size);
+" (size %zu).\n", rec_size);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (EC_READ_U16(data) >> 12 == 0x8 && // SDO information
 (EC_READ_U8 (data + 2) & 0x7F) == 0x07) { // error response
-EC_ERR("SDO information error response at slave %u while"
+EC_SLAVE_ERR(slave, "SDO information error response while"
-" fetching SDO 0x%04X!\n", slave->ring_position,
+" fetching SDO 0x%04X!\n", sdo->index);
-sdo->index);
+ec_canopen_abort_msg(slave, EC_READ_U32(data + 6));
-ec_canopen_abort_msg(EC_READ_U32(data + 6));
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (rec_size < 8) {
-EC_ERR("Received corrupted SDO description response (size %zu).\n",
+EC_SLAVE_ERR(slave, "Received corrupted SDO"
-rec_size);
+" description response (size %zu).\n", rec_size);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (EC_READ_U16(data) >> 12 != 0x8 || // SDO information
 (EC_READ_U8 (data + 2) & 0x7F) != 0x04 || // Object desc. response
 EC_READ_U16(data + 6) != sdo->index) { // SDO index
 if (fsm->slave->master->debug_level) {
-EC_DBG("Invalid object description response at slave %u while"
+EC_SLAVE_DBG(slave, 1, "Invalid object description response while"
-" fetching SDO 0x%04X!\n", slave->ring_position,
+" fetching SDO 0x%04X!\n", sdo->index);
-sdo->index);
 ec_print_data(data, rec_size);
 }
 // check for CoE response again
 ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
 fsm->retries = EC_FSM_RETRIES;
 fsm->state = ec_fsm_coe_dict_desc_check;
 return;
 }
 if (rec_size < 12) {
-EC_ERR("Invalid data size!\n");
+EC_SLAVE_ERR(slave, "Invalid data size!\n");
 ec_print_data(data, rec_size);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 sdo->object_code = EC_READ_U8(data + 11);
 name_size = rec_size - 12;
 if (name_size) {
 if (!(sdo->name = kmalloc(name_size + 1, GFP_KERNEL))) {
-EC_ERR("Failed to allocate SDO name!\n");
+EC_SLAVE_ERR(slave, "Failed to allocate SDO name!\n");
 fsm->state = ec_fsm_coe_error;
 return;
 }
 memcpy(sdo->name, data + 12, name_size);
 sdo->name[name_size] = 0;
 }
 if (EC_READ_U8(data + 2) & 0x80) {
-EC_ERR("Fragment follows (not implemented)!\n");
+EC_SLAVE_ERR(slave, "Fragment follows (not implemented)!\n");
 fsm->state = ec_fsm_coe_error;
 return;
 }
 // start fetching entries
 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_coe_error;
-EC_ERR("Failed to receive CoE SDO entry request datagram for"
+EC_SLAVE_ERR(slave, "Failed to receive CoE SDO entry"
-" slave %u: ", slave->ring_position);
+" request datagram: ");
 ec_datagram_print_state(datagram);
 return;
 }
 if (datagram->working_counter != 1) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Reception of CoE SDO entry request failed on slave %u: ",
+EC_SLAVE_ERR(slave, "Reception of CoE SDO entry request failed: ");
-slave->ring_position);
 ec_datagram_print_wc_error(datagram);
 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_coe_error;
-EC_ERR("Failed to receive CoE mailbox check datagram from slave %u"
+EC_SLAVE_ERR(slave, "Failed to receive CoE mailbox check datagram: ");
-": ", slave->ring_position);
 ec_datagram_print_state(datagram);
 return;
 }
 if (datagram->working_counter != 1) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Reception of CoE mailbox check"
+EC_SLAVE_ERR(slave, "Reception of CoE mailbox check"
-" datagram failed on slave %u: ", slave->ring_position);
+" 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 >= EC_FSM_COE_DICT_TIMEOUT) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Timeout while waiting for SDO entry 0x%04x:%x"
+EC_SLAVE_ERR(slave, "Timeout while waiting for"
-" description response on slave %u.\n",
+" SDO entry 0x%04x:%x description response.\n",
-fsm->sdo->index, fsm->subindex, slave->ring_position);
+fsm->sdo->index, fsm->subindex);
 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_coe_error;
-EC_ERR("Failed to receive CoE SDO description response datagram from"
+EC_SLAVE_ERR(slave, "Failed to receive CoE SDO"
-" slave %u: ", slave->ring_position);
+" description response datagram: ");
 ec_datagram_print_state(datagram);
 return;
 }
 if (datagram->working_counter != 1) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Reception of CoE SDO description"
+EC_SLAVE_ERR(slave, "Reception of CoE SDO description"
-" response failed on slave %u: ", slave->ring_position);
+" response failed: ");
 ec_datagram_print_wc_error(datagram);
 return;
 }
 data = ec_slave_mbox_fetch(slave, datagram, &mbox_prot, &rec_size);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (mbox_prot != 0x03) { // CoE
-EC_ERR("Received mailbox protocol 0x%02X as response.\n", mbox_prot);
+EC_SLAVE_ERR(slave, "Received mailbox protocol"
+" 0x%02X as response.\n", mbox_prot);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (ec_fsm_coe_check_emergency(fsm, data, rec_size)) {
 fsm->state = ec_fsm_coe_dict_entry_check;
 return;
 }
 if (rec_size < 3) {
-EC_ERR("Received corrupted SDO entry description response "
+EC_SLAVE_ERR(slave, "Received corrupted SDO entry"
-"(size %zu).\n", rec_size);
+" description response (size %zu).\n", rec_size);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (EC_READ_U16(data) >> 12 == 0x8 && // SDO information
 (EC_READ_U8 (data + 2) & 0x7F) == 0x07) { // error response
-EC_ERR("SDO information error response at slave %u while"
+EC_SLAVE_ERR(slave, "SDO information error response while"
-" fetching SDO entry 0x%04X:%02X!\n", slave->ring_position,
+" fetching SDO entry 0x%04X:%02X!\n",
 sdo->index, fsm->subindex);
-ec_canopen_abort_msg(EC_READ_U32(data + 6));
+ec_canopen_abort_msg(slave, EC_READ_U32(data + 6));
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (rec_size < 9) {
-EC_ERR("Received corrupted SDO entry description response "
+EC_SLAVE_ERR(slave, "Received corrupted SDO entry"
-"(size %zu).\n", rec_size);
+" description response (size %zu).\n", rec_size);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (EC_READ_U16(data) >> 12 != 0x8 || // SDO information
 (EC_READ_U8(data + 2) & 0x7F) != 0x06 || // Entry desc. response
 EC_READ_U16(data + 6) != sdo->index || // SDO index
 EC_READ_U8(data + 8) != fsm->subindex) { // SDO subindex
 if (fsm->slave->master->debug_level) {
-EC_DBG("Invalid entry description response at slave %u while"
+EC_SLAVE_DBG(slave, 1, "Invalid entry description response while"
-" fetching SDO entry 0x%04X:%02X!\n", slave->ring_position,
+" fetching SDO entry 0x%04X:%02X!\n",
 sdo->index, fsm->subindex);
 ec_print_data(data, rec_size);
 }
 // check for CoE response again
 ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
 fsm->state = ec_fsm_coe_dict_entry_check;
 return;
 }
 if (rec_size < 16) {
-EC_ERR("Invalid data size %zu!\n", rec_size);
+EC_SLAVE_ERR(slave, "Invalid data size %zu!\n", rec_size);
 ec_print_data(data, rec_size);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 data_size = rec_size - 16;
 if (!(entry = (ec_sdo_entry_t *)
 kmalloc(sizeof(ec_sdo_entry_t), GFP_KERNEL))) {
-EC_ERR("Failed to allocate entry!\n");
+EC_SLAVE_ERR(slave, "Failed to allocate entry!\n");
 fsm->state = ec_fsm_coe_error;
 return;
 }
 ec_sdo_entry_init(entry, sdo, fsm->subindex);
 entry->write_access[EC_SDO_ENTRY_ACCESS_OP] = (word >> 5)  & 0x0001;
 if (data_size) {
 uint8_t *desc;
 if (!(desc = kmalloc(data_size + 1, GFP_KERNEL))) {
-EC_ERR("Failed to allocate SDO entry name!\n");
+EC_SLAVE_ERR(slave, "Failed to allocate SDO entry name!\n");
 fsm->state = ec_fsm_coe_error;
 return;
 }
 memcpy(desc, data + 16, data_size);
 desc[data_size] = 0;
 if (request->complete_access) {
 subidxstr[0] = 0x00;
 } else {
 sprintf(subidxstr, ":%02X", request->subindex);
 }
-EC_DBG("Downloading SDO 0x%04X%s to slave %u.\n",
+EC_SLAVE_DBG(slave, 1, "Downloading SDO 0x%04X%s.\n",
-request->index, subidxstr, slave->ring_position);
+request->index, subidxstr);
 ec_print_data(request->data, request->data_size);
 }
 if (!(slave->sii.mailbox_protocols & EC_MBOX_COE)) {
-EC_ERR("Slave %u does not support CoE!\n", slave->ring_position);
+EC_SLAVE_ERR(slave, "Slave does not support CoE!\n");
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (slave->configured_rx_mailbox_size <
 EC_MBOX_HEADER_SIZE + EC_COE_DOWN_REQ_HEADER_SIZE) {
-EC_ERR("Mailbox too small!\n");
+EC_SLAVE_ERR(slave, "Mailbox too small!\n");
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (request->data_size <= 4) { // use expedited transfer type
 request->complete_access ? 0x00 : request->subindex);
 memcpy(data + 6, request->data, request->data_size);
 memset(data + 6 + request->data_size, 0x00, 4 - request->data_size);
 if (slave->master->debug_level) {
-EC_DBG("Expedited download request:\n");
+EC_SLAVE_DBG(slave, 1, "Expedited download request:\n");
 ec_print_data(data, EC_COE_DOWN_REQ_HEADER_SIZE);
 }
 }
 else { // request->data_size > 4, use normal transfer type
 size_t data_size,
 fsm->offset += segment_size;
 fsm->remaining -= segment_size;
 }
 if (slave->master->debug_level) {
-EC_DBG("Normal download request:\n");
+EC_SLAVE_DBG(slave, 1, "Normal download request:\n");
 ec_print_data(data, data_size);
 }
 }
 fsm->request->jiffies_sent = jiffies;
 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_coe_error;
-EC_ERR("Failed to receive CoE download request datagram for"
+EC_SLAVE_ERR(slave, "Failed to receive CoE download"
-" slave %u: ", slave->ring_position);
+" request datagram: ");
 ec_datagram_print_state(datagram);
 return;
 }
 diff_ms = (jiffies - fsm->request->jiffies_sent) * 1000 / HZ;
 if (datagram->working_counter != 1) {
 if (!datagram->working_counter) {
 if (diff_ms < fsm->request->response_timeout) {
 #if DEBUG_RETRIES
-if (fsm->slave->master->debug_level) {
+EC_SLAVE_DBG(slave, 1, "Slave did not respond to"
-EC_DBG("Slave %u did not respond to SDO download request. "
+" SDO download request. Retrying after %u ms...\n",
-"Retrying after %u ms...\n",
+(u32) diff_ms);
-slave->ring_position, (u32) diff_ms);
-}
 #endif
 // no response; send request datagram again
 return;
 }
 }
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Reception of CoE download request for SDO 0x%04x:%x failed"
+EC_SLAVE_ERR(slave, "Reception of CoE download request"
-" with timeout after %u ms on slave %u: ",
+" for SDO 0x%04x:%x failed with timeout after %u ms: ",
-fsm->request->index, fsm->request->subindex, (u32) diff_ms,
+fsm->request->index, fsm->request->subindex, (u32) diff_ms);
-fsm->slave->ring_position);
 ec_datagram_print_wc_error(datagram);
 return;
 }
 #if DEBUG_LONG
 if (diff_ms > 200) {
-EC_WARN("SDO 0x%04x:%x download took %u ms on slave %u.\n",
+EC_SLAVE_WARN(slave, "SDO 0x%04x:%x download took %u ms.\n",
-fsm->request->index, fsm->request->subindex, (u32) diff_ms,
+fsm->request->index, fsm->request->subindex, (u32) diff_ms);
-fsm->slave->ring_position);
 }
 #endif
 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_coe_error;
-EC_ERR("Failed to receive CoE mailbox check datagram for slave %u: ",
+EC_SLAVE_ERR(slave, "Failed to receive CoE mailbox check"
-slave->ring_position);
+" datagram: ");
 ec_datagram_print_state(datagram);
 return;
 }
 if (datagram->working_counter != 1) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Reception of CoE mailbox check"
+EC_SLAVE_ERR(slave, "Reception of CoE mailbox check"
-" datagram failed on slave %u: ", slave->ring_position);
+" 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->state = ec_fsm_coe_error;
-EC_ERR("Timeout after %u ms while waiting for SDO 0x%04x:%x"
+EC_SLAVE_ERR(slave, "Timeout after %u ms while waiting"
-" download response on slave %u.\n", (u32) diff_ms,
+" for SDO 0x%04x:%x download response.\n", (u32) diff_ms,
-fsm->request->index, fsm->request->subindex,
+fsm->request->index, fsm->request->subindex);
-slave->ring_position);
 return;
 }
 ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
 fsm->retries = EC_FSM_RETRIES;
 fsm->offset += segment_size;
 fsm->remaining -= segment_size;
 if (slave->master->debug_level) {
-EC_DBG("Download segment request:\n");
+EC_SLAVE_DBG(slave, 1, "Download segment request:\n");
 ec_print_data(data, data_size);
 }
 fsm->state = ec_fsm_coe_down_seg_check;
 }
 if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 return; // FIXME: request again?
 if (datagram->state != EC_DATAGRAM_RECEIVED) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Failed to receive CoE download response datagram from"
+EC_SLAVE_ERR(slave, "Failed to receive CoE download"
-" slave %u: ", slave->ring_position);
+" response datagram: ");
 ec_datagram_print_state(datagram);
 return;
 }
 if (datagram->working_counter != 1) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Reception of CoE download response failed on slave %u: ",
+EC_SLAVE_ERR(slave, "Reception of CoE download response failed: ");
-slave->ring_position);
 ec_datagram_print_wc_error(datagram);
 return;
 }
 data = ec_slave_mbox_fetch(slave, datagram, &mbox_prot, &rec_size);
 return;
 }
 if (mbox_prot != 0x03) { // CoE
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Received mailbox protocol 0x%02X as response.\n", mbox_prot);
+EC_SLAVE_ERR(slave, "Received mailbox protocol 0x%02X as response.\n",
+mbox_prot);
 return;
 }
 if (ec_fsm_coe_check_emergency(fsm, data, rec_size)) {
 // check for CoE response again
 fsm->state = ec_fsm_coe_down_check;
 return;
 }
 if (slave->master->debug_level) {
-EC_DBG("Download response:\n");
+EC_SLAVE_DBG(slave, 1, "Download response:\n");
 ec_print_data(data, rec_size);
 }
 if (rec_size < 6) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Received data are too small (%zu bytes):\n", rec_size);
+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
 if (request->complete_access) {
 subidxstr[0] = 0x00;
 } else {
 sprintf(subidxstr, ":%02X", request->subindex);
 }
-EC_ERR("SDO download 0x%04X%s (%zu bytes) aborted on slave %u.\n",
+EC_SLAVE_ERR(slave, "SDO download 0x%04X%s (%zu bytes) aborted.\n",
-request->index, subidxstr, request->data_size,
+request->index, subidxstr, request->data_size);
-slave->ring_position);
 if (rec_size < 10) {
-EC_ERR("Incomplete abort command:\n");
+EC_SLAVE_ERR(slave, "Incomplete abort command:\n");
 ec_print_data(data, rec_size);
 } else {
 fsm->request->abort_code = EC_READ_U32(data + 6);
-ec_canopen_abort_msg(fsm->request->abort_code);
+ec_canopen_abort_msg(slave, fsm->request->abort_code);
 }
 return;
 }
 if (EC_READ_U16(data) >> 12 != 0x3 || // SDO response
 EC_READ_U8 (data + 2) >> 5 != 0x3 || // Download response
 EC_READ_U16(data + 3) != request->index || // index
 EC_READ_U8 (data + 5) != request->subindex) { // subindex
 if (slave->master->debug_level) {
-EC_DBG("Invalid SDO download response at slave %u! Retrying...\n",
+EC_SLAVE_DBG(slave, 1, "Invalid SDO download response!"
-slave->ring_position);
+" Retrying...\n");
 ec_print_data(data, rec_size);
 }
 // check for CoE response again
 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;
 if (datagram->state != EC_DATAGRAM_RECEIVED) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Failed to receive CoE mailbox check datagram for slave %u: ",
+EC_SLAVE_ERR(slave, "Failed to receive CoE mailbox check datagram: ");
-slave->ring_position);
 ec_datagram_print_state(datagram);
 return;
 }
 if (datagram->working_counter != 1) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Reception of CoE mailbox segment check"
+EC_SLAVE_ERR(slave, "Reception of CoE mailbox segment check"
-" datagram failed on slave %u: ", slave->ring_position);
+" 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->state = ec_fsm_coe_error;
-EC_ERR("Timeout while waiting for SDO download segment response "
+EC_SLAVE_ERR(slave, "Timeout while waiting for SDO download"
-"on slave %u.\n", slave->ring_position);
+" segment response.\n");
 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_coe_error;
-EC_ERR("Failed to receive CoE download response datagram from"
+EC_SLAVE_ERR(slave, "Failed to receive CoE download response"
-" slave %u: ", slave->ring_position);
+" datagram: ");
 ec_datagram_print_state(datagram);
 return;
 }
 if (datagram->working_counter != 1) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Reception of CoE download response failed on slave %u: ",
+EC_SLAVE_ERR(slave, "Reception of CoE download response failed: ");
-slave->ring_position);
 ec_datagram_print_wc_error(datagram);
 return;
 }
 data = ec_slave_mbox_fetch(slave, datagram, &mbox_prot, &rec_size);
 return;
 }
 if (mbox_prot != 0x03) { // CoE
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Received mailbox protocol 0x%02X as response.\n", mbox_prot);
+EC_SLAVE_ERR(slave, "Received mailbox protocol 0x%02X as response.\n",
+mbox_prot);
 return;
 }
 if (ec_fsm_coe_check_emergency(fsm, data, rec_size)) {
 // check for CoE response again
 fsm->state = ec_fsm_coe_down_check;
 return;
 }
 if (slave->master->debug_level) {
-EC_DBG("Download response:\n");
+EC_SLAVE_DBG(slave, 1, "Download response:\n");
 ec_print_data(data, rec_size);
 }
 if (rec_size < 6) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Received data are too small (%zu bytes):\n", rec_size);
+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
 if (request->complete_access) {
 subidxstr[0] = 0x00;
 } else {
 sprintf(subidxstr, ":%02X", request->subindex);
 }
-EC_ERR("SDO download 0x%04X%s (%zu bytes) aborted on slave %u.\n",
+EC_SLAVE_ERR(slave, "SDO download 0x%04X%s (%zu bytes) aborted.\n",
-request->index, subidxstr, request->data_size,
+request->index, subidxstr, request->data_size);
-slave->ring_position);
 if (rec_size < 10) {
-EC_ERR("Incomplete abort command:\n");
+EC_SLAVE_ERR(slave, "Incomplete abort command:\n");
 ec_print_data(data, rec_size);
 } else {
 fsm->request->abort_code = EC_READ_U32(data + 6);
-ec_canopen_abort_msg(fsm->request->abort_code);
+ec_canopen_abort_msg(slave, fsm->request->abort_code);
 }
 return;
 }
 if (EC_READ_U16(data) >> 12 != 0x3 ||
 ((EC_READ_U8(data + 2) >> 5) != 0x01)) { // segment response
 if (slave->master->debug_level) {
-EC_DBG("Invalid SDO download response at slave %u! Retrying...\n",
+EC_SLAVE_DBG(slave, 1, "Invalid SDO download response!"
-slave->ring_position);
+" Retrying...\n");
 ec_print_data(data, rec_size);
 }
 // check for CoE response again
 ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
 fsm->retries = EC_FSM_RETRIES;
 fsm->state = ec_fsm_coe_down_seg_check;
 return;
 }
 if (((EC_READ_U8(data + 2) >> 4) & 0x01) != fsm->toggle) {
-EC_ERR("Invalid toggle received during segmented download:\n");
+EC_SLAVE_ERR(slave, "Invalid toggle received during"
+" segmented download:\n");
 ec_print_data(data, rec_size);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 ec_slave_t *slave = fsm->slave;
 ec_master_t *master = slave->master;
 ec_sdo_request_t *request = fsm->request;
 uint8_t *data;
-if (master->debug_level)
+EC_SLAVE_DBG(slave, 1, "Uploading SDO 0x%04X:%02X.\n",
-EC_DBG("Uploading SDO 0x%04X:%02X from slave %u.\n",
+request->index, request->subindex);
-request->index, request->subindex, slave->ring_position);
 if (!(slave->sii.mailbox_protocols & EC_MBOX_COE)) {
-EC_ERR("Slave %u does not support CoE!\n", slave->ring_position);
+EC_SLAVE_ERR(slave, "Slave does not support CoE!\n");
 fsm->state = ec_fsm_coe_error;
 return;
 }
 data = ec_slave_mbox_prepare_send(slave, datagram, 0x03, 10);
 EC_WRITE_U16(data + 3, request->index);
 EC_WRITE_U8 (data + 5, request->subindex);
 memset(data + 6, 0x00, 4);
 if (master->debug_level) {
-EC_DBG("Upload request:\n");
+EC_SLAVE_DBG(slave, 1, "Upload request:\n");
 ec_print_data(data, 10);
 }
 fsm->request->jiffies_sent = jiffies;
 fsm->retries = EC_FSM_RETRIES;
 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_coe_error;
-EC_ERR("Failed to receive CoE upload request for slave %u: ",
+EC_SLAVE_ERR(slave, "Failed to receive CoE upload request: ");
-slave->ring_position);
 ec_datagram_print_state(datagram);
 return;
 }
 diff_ms = (jiffies - fsm->request->jiffies_sent) * 1000 / HZ;
 if (datagram->working_counter != 1) {
 if (!datagram->working_counter) {
 if (diff_ms < fsm->request->response_timeout) {
 #if DEBUG_RETRIES
-if (fsm->slave->master->debug_level) {
+EC_SLAVE_DBG(slave, 1, "Slave did not respond to"
-EC_DBG("Slave %u did not respond to SDO upload request. "
+" SDO upload request. Retrying after %u ms...\n",
-"Retrying after %u ms...\n",
+(u32) diff_ms);
-slave->ring_position, (u32) diff_ms);
-}
 #endif
 // no response; send request datagram again
 return;
 }
 }
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Reception of CoE upload request for SDO 0x%04x:%x failed"
+EC_SLAVE_ERR(slave, "Reception of CoE upload request for"
-" with timeout after %u ms on slave %u: ",
+" SDO 0x%04x:%x failed with timeout after %u ms: ",
-fsm->request->index, fsm->request->subindex, (u32) diff_ms,
+fsm->request->index, fsm->request->subindex, (u32) diff_ms);
-fsm->slave->ring_position);
 ec_datagram_print_wc_error(datagram);
 return;
 }
 #if DEBUG_LONG
 if (diff_ms > 200) {
-EC_WARN("SDO 0x%04x:%x upload took %u ms on slave %u.\n",
+EC_SLAVE_WARN(slave, "SDO 0x%04x:%x upload took %u ms.\n",
-fsm->request->index, fsm->request->subindex, (u32) diff_ms,
+fsm->request->index, fsm->request->subindex, (u32) diff_ms);
-fsm->slave->ring_position);
 }
 #endif
 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_coe_error;
-EC_ERR("Failed to receive CoE mailbox check datagram from slave %u: ",
+EC_SLAVE_ERR(slave, "Failed to receive CoE mailbox check datagram: ");
-slave->ring_position);
 ec_datagram_print_state(datagram);
 return;
 }
 if (datagram->working_counter != 1) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Reception of CoE mailbox check"
+EC_SLAVE_ERR(slave, "Reception of CoE mailbox check"
-" datagram failed on slave %u: ", slave->ring_position);
+" 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->state = ec_fsm_coe_error;
-EC_ERR("Timeout after %u ms while waiting for SDO 0x%04x:%x"
+EC_SLAVE_ERR(slave, "Timeout after %u ms while waiting for"
-" upload response on slave %u.\n", (u32) diff_ms,
+" SDO 0x%04x:%x upload response.\n", (u32) diff_ms,
-fsm->request->index, fsm->request->subindex,
+fsm->request->index, fsm->request->subindex);
-slave->ring_position);
 return;
 }
 ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
 fsm->retries = EC_FSM_RETRIES;
 EC_WRITE_U8 (data + 2, (fsm->toggle << 4 // toggle
 | 0x3 << 5)); // upload segment request
 memset(data + 3, 0x00, 7);
 if (fsm->slave->master->debug_level) {
-EC_DBG("Upload segment request:\n");
+EC_SLAVE_DBG(fsm->slave, 1, "Upload segment request:\n");
 ec_print_data(data, 10);
 }
 }
 /*****************************************************************************/
 if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
 return; // FIXME: request again?
 if (datagram->state != EC_DATAGRAM_RECEIVED) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Failed to receive CoE upload response datagram for"
+EC_SLAVE_ERR(slave, "Failed to receive CoE upload response"
-" slave %u: ", slave->ring_position);
+" datagram: ");
 ec_datagram_print_state(datagram);
 return;
 }
 if (datagram->working_counter != 1) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Reception of CoE upload response failed on slave %u: ",
+EC_SLAVE_ERR(slave, "Reception of CoE upload response failed: ");
-slave->ring_position);
 ec_datagram_print_wc_error(datagram);
 return;
 }
 data = ec_slave_mbox_fetch(slave, datagram, &mbox_prot, &rec_size);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (master->debug_level) {
-EC_DBG("Upload response:\n");
+EC_SLAVE_DBG(slave, 1, "Upload response:\n");
 ec_print_data(data, rec_size);
 }
 if (mbox_prot != 0x03) { // CoE
 fsm->state = ec_fsm_coe_error;
-EC_WARN("Received mailbox protocol 0x%02X as response.\n", mbox_prot);
+EC_SLAVE_WARN(slave, "Received mailbox protocol 0x%02X"
+" as response.\n", mbox_prot);
 return;
 }
 if (ec_fsm_coe_check_emergency(fsm, data, rec_size)) {
 // check for CoE response again
 return;
 }
 if (rec_size < 6) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Received currupted SDO upload response (%zu bytes)!\n", rec_size);
+EC_SLAVE_ERR(slave, "Received currupted SDO upload response"
+" (%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
-EC_ERR("SDO upload 0x%04X:%02X aborted on slave %u.\n",
+EC_SLAVE_ERR(slave, "SDO upload 0x%04X:%02X aborted.\n",
-request->index, request->subindex, slave->ring_position);
+request->index, request->subindex);
 if (rec_size >= 10) {
 request->abort_code = EC_READ_U32(data + 6);
-ec_canopen_abort_msg(request->abort_code);
+ec_canopen_abort_msg(slave, request->abort_code);
 } else {
-EC_ERR("No abort message.\n");
+EC_SLAVE_ERR(slave, "No abort message.\n");
 }
 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_ERR("Received unknown response while uploading SDO 0x%04X:%02X"
+EC_SLAVE_ERR(slave, "Received unknown response while"
-" from slave %u.\n", request->index, request->subindex,
+" uploading SDO 0x%04X:%02X.\n",
-slave->ring_position);
+request->index, request->subindex);
 ec_print_data(data, rec_size);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 rec_index = EC_READ_U16(data + 3);
 rec_subindex = EC_READ_U8(data + 5);
 if (rec_index != request->index || rec_subindex != request->subindex) {
-EC_ERR("Received upload response for wrong SDO (0x%04X:%02X,"
+EC_SLAVE_ERR(slave, "Received upload response for wrong SDO"
-" requested: 0x%04X:%02X) from slave %u.\n",
+" (0x%04X:%02X, requested: 0x%04X:%02X).\n",
-rec_index, rec_subindex, request->index, request->subindex,
+rec_index, rec_subindex, request->index, request->subindex);
-slave->ring_position);
 ec_print_data(data, rec_size);
 // check for CoE response again
 ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
 fsm->retries = EC_FSM_RETRIES;
 fsm->complete_size = 4;
 }
 if (rec_size < 6 + fsm->complete_size) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Received corrupted SDO expedited upload"
+EC_SLAVE_ERR(slave, "Received corrupted SDO expedited upload"
 " response (only %zu bytes)!\n", rec_size);
 ec_print_data(data, rec_size);
 return;
 }
 return;
 }
 } else { // normal
 if (rec_size < 10) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Received currupted SDO normal upload"
+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) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("No complete size supplied!\n");
+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)) {
 }
 fsm->toggle = 0;
 if (data_size < fsm->complete_size) {
-if (master->debug_level)
+EC_SLAVE_DBG(slave, 1, "SDO data incomplete (%zu / %u)."
-EC_DBG("SDO data incomplete (%zu / %u). Segmenting...\n",
+" Segmenting...\n", data_size, fsm->complete_size);
-data_size, fsm->complete_size);
 ec_fsm_coe_up_prepare_segment_request(fsm);
 fsm->retries = EC_FSM_RETRIES;
 fsm->state = ec_fsm_coe_up_seg_request;
 return;
 }
 }
 if (master->debug_level) {
-EC_DBG("Uploaded data:\n");
+EC_SLAVE_DBG(slave, 1, "Uploaded data:\n");
 ec_print_data(request->data, request->data_size);
 }
 fsm->state = ec_fsm_coe_end; // success
 }
 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_coe_error;
-EC_ERR("Failed to receive CoE upload segment request datagram for"
+EC_SLAVE_ERR(slave, "Failed to receive CoE upload segment"
-" slave %u: ", slave->ring_position);
+" request datagram: ");
 ec_datagram_print_state(datagram);
 return;
 }
 if (datagram->working_counter != 1) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Reception of CoE upload segment"
+EC_SLAVE_ERR(slave, "Reception of CoE upload segment"
-" request failed on slave %u: ", slave->ring_position);
+" request failed: ");
 ec_datagram_print_wc_error(datagram);
 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_coe_error;
-EC_ERR("Failed to receive CoE mailbox check datagram for slave %u: ",
+EC_SLAVE_ERR(slave, "Failed to receive CoE mailbox check"
-slave->ring_position);
+" datagram: ");
 ec_datagram_print_state(datagram);
 return;
 }
 if (datagram->working_counter != 1) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Reception of CoE mailbox check"
+EC_SLAVE_ERR(slave, "Reception of CoE mailbox check datagram"
-" datagram failed on slave %u: ", slave->ring_position);
+" 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->state = ec_fsm_coe_error;
-EC_ERR("Timeout while waiting for SDO upload segment response "
+EC_SLAVE_ERR(slave, "Timeout while waiting for SDO upload"
-"on slave %u.\n", slave->ring_position);
+" segment response.\n");
 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_coe_error;
-EC_ERR("Failed to receive CoE upload segment response datagram for"
+EC_SLAVE_ERR(slave, "Failed to receive CoE upload segment"
-" slave %u: ", slave->ring_position);
+" response datagram: ");
 ec_datagram_print_state(datagram);
 return;
 }
 if (datagram->working_counter != 1) {
 fsm->state = ec_fsm_coe_error;
-EC_ERR("Reception of CoE upload segment"
+EC_SLAVE_ERR(slave, "Reception of CoE upload segment"
-" response failed on slave %u: ", slave->ring_position);
+" response failed: ");
 ec_datagram_print_wc_error(datagram);
 return;
 }
 data = ec_slave_mbox_fetch(slave, datagram, &mbox_prot, &rec_size);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (master->debug_level) {
-EC_DBG("Upload segment response:\n");
+EC_SLAVE_DBG(slave, 1, "Upload segment response:\n");
 ec_print_data(data, rec_size);
 }
 if (mbox_prot != 0x03) { // CoE
-EC_ERR("Received mailbox protocol 0x%02X as response.\n", mbox_prot);
+EC_SLAVE_ERR(slave, "Received mailbox protocol 0x%02X as response.\n",
+mbox_prot);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (ec_fsm_coe_check_emergency(fsm, data, rec_size)) {
 fsm->state = ec_fsm_coe_up_seg_check;
 return;
 }
 if (rec_size < 10) {
-EC_ERR("Received currupted SDO upload segment response!\n");
+EC_SLAVE_ERR(slave, "Received currupted SDO upload"
+" segment response!\n");
 ec_print_data(data, rec_size);
 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_ERR("SDO upload 0x%04X:%02X aborted on slave %u.\n",
+EC_SLAVE_ERR(slave, "SDO upload 0x%04X:%02X aborted.\n",
-request->index, request->subindex, slave->ring_position);
+request->index, request->subindex);
 request->abort_code = EC_READ_U32(data + 6);
-ec_canopen_abort_msg(request->abort_code);
+ec_canopen_abort_msg(slave, request->abort_code);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 if (EC_READ_U16(data) >> 12 != 0x3 || // SDO response
 EC_READ_U8 (data + 2) >> 5 != 0x0) { // upload segment response
 if (fsm->slave->master->debug_level) {
-EC_DBG("Invalid SDO upload segment response at slave %u!\n",
+EC_SLAVE_DBG(slave, 1, "Invalid SDO upload segment response!\n");
-slave->ring_position);
 ec_print_data(data, rec_size);
 }
 // check for CoE response again
 ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
 fsm->retries = EC_FSM_RETRIES;
 uint8_t seg_size = (EC_READ_U8(data + 2) & 0xE) >> 1;
 data_size -= seg_size;
 }
 if (request->data_size + data_size > fsm->complete_size) {
-EC_ERR("SDO upload 0x%04X:%02X failed on slave %u: Fragment"
+EC_SLAVE_ERR(slave, "SDO upload 0x%04X:%02X failed: Fragment"
 " exceeding complete size!\n",
-request->index, request->subindex, slave->ring_position);
+request->index, request->subindex);
 fsm->state = ec_fsm_coe_error;
 return;
 }
 memcpy(request->data + request->data_size, data + 3, data_size);
 fsm->state = ec_fsm_coe_up_seg_request;
 return;
 }
 if (request->data_size != fsm->complete_size) {
-EC_WARN("SDO upload 0x%04X:%02X on slave %u: Assembled data"
+EC_SLAVE_WARN(slave, "SDO upload 0x%04X:%02X: Assembled data"
 " size (%zu) does not match complete size (%u)!\n",
-request->index, request->subindex, slave->ring_position,
+request->index, request->subindex,
 request->data_size, fsm->complete_size);
 }
 if (master->debug_level) {
-EC_DBG("Uploaded data:\n");
+EC_SLAVE_DBG(slave, 1, "Uploaded data:\n");
 ec_print_data(request->data, request->data_size);
 }
 fsm->state = ec_fsm_coe_end; // success
 }

changeset 1989	6aa393418fb3
parent 1923	712d04506f12
child 1931	831f2d34664c