etherlabmaster: comparison master/master.c

equal deleted inserted replaced

-:d28360ee74c5
+:d9cf40facbc4
 ec_datagram_init(&master->fsm_datagram);
 snprintf(master->fsm_datagram.name, EC_DATAGRAM_NAME_SIZE, "master-fsm");
 ret = ec_datagram_prealloc(&master->fsm_datagram, EC_MAX_DATA_SIZE);
 if (ret < 0) {
 ec_datagram_clear(&master->fsm_datagram);
-EC_ERR("Failed to allocate FSM datagram.\n");
+EC_MASTER_ERR(master, "Failed to allocate FSM datagram.\n");
 goto out_clear_backup;
 }
 // create state machine object
 ec_fsm_master_init(&master->fsm, master, &master->fsm_datagram);
 ec_datagram_init(&master->ref_sync_datagram);
 snprintf(master->ref_sync_datagram.name, EC_DATAGRAM_NAME_SIZE, "refsync");
 ret = ec_datagram_apwr(&master->ref_sync_datagram, 0, 0x0910, 8);
 if (ret < 0) {
 ec_datagram_clear(&master->ref_sync_datagram);
-EC_ERR("Failed to allocate reference synchronisation datagram.\n");
+EC_MASTER_ERR(master, "Failed to allocate reference"
+" synchronisation datagram.\n");
 goto out_clear_fsm;
 }
 // init sync datagram
 ec_datagram_init(&master->sync_datagram);
 snprintf(master->sync_datagram.name, EC_DATAGRAM_NAME_SIZE, "sync");
 ret = ec_datagram_prealloc(&master->sync_datagram, 4);
 if (ret < 0) {
 ec_datagram_clear(&master->sync_datagram);
-EC_ERR("Failed to allocate synchronisation datagram.\n");
+EC_MASTER_ERR(master, "Failed to allocate"
+" synchronisation datagram.\n");
 goto out_clear_ref_sync;
 }
 // init sync monitor datagram
 ec_datagram_init(&master->sync_mon_datagram);
 snprintf(master->sync_mon_datagram.name, EC_DATAGRAM_NAME_SIZE, "syncmon");
 ret = ec_datagram_brd(&master->sync_mon_datagram, 0x092c, 4);
 if (ret < 0) {
 ec_datagram_clear(&master->sync_mon_datagram);
-EC_ERR("Failed to allocate sync monitoring datagram.\n");
+EC_MASTER_ERR(master, "Failed to allocate sync"
+" monitoring datagram.\n");
 goto out_clear_sync;
 }
 ec_master_find_dc_ref_clock(master);
 master->class_device = class_device_create(class,
 MKDEV(MAJOR(device_number), master->index), NULL,
 "EtherCAT%u", master->index);
 #endif
 if (IS_ERR(master->class_device)) {
-EC_ERR("Failed to create class device!\n");
+EC_MASTER_ERR(master, "Failed to create class device!\n");
 ret = PTR_ERR(master->class_device);
 goto out_clear_cdev;
 }
 return 0;
 master->dc_ref_clock = NULL;
 // external requests are obsolete, so we wake pending waiters and remove
 // them from the list
-//
-// SII requests
+while (!list_empty(&master->sii_requests)) {
-while (1) {
+ec_sii_write_request_t *request =
-ec_sii_write_request_t *request;
+list_entry(master->sii_requests.next,
-if (list_empty(&master->sii_requests))
+ec_sii_write_request_t, list);
-break;
-// get first request
-request = list_entry(master->sii_requests.next,
-ec_sii_write_request_t, list);
 list_del_init(&request->list); // dequeue
-EC_INFO("Discarding SII request, slave %u does not exist anymore.\n",
+EC_MASTER_WARN(master, "Discarding SII request, slave %u about"
-request->slave->ring_position);
+" to be deleted.\n", request->slave->ring_position);
 request->state = EC_INT_REQUEST_FAILURE;
 wake_up(&master->sii_queue);
 }
-// Register requests
+while (!list_empty(&master->reg_requests)) {
-while (1) {
+ec_reg_request_t *request =
-ec_reg_request_t *request;
+list_entry(master->reg_requests.next, ec_reg_request_t, list);
-if (list_empty(&master->reg_requests))
-break;
-// get first request
-request = list_entry(master->reg_requests.next,
-ec_reg_request_t, list);
 list_del_init(&request->list); // dequeue
-EC_INFO("Discarding Reg request, slave %u does not exist anymore.\n",
+EC_MASTER_WARN(master, "Discarding register request, slave %u"
-request->slave->ring_position);
+" about to be deleted.\n", request->slave->ring_position);
 request->state = EC_INT_REQUEST_FAILURE;
 wake_up(&master->reg_queue);
 }
 for (slave = master->slaves;
 slave < master->slaves + master->slave_count;
 slave++) {
-// SDO requests
-while (1) {
-ec_master_sdo_request_t *request;
-if (list_empty(&slave->slave_sdo_requests))
-break;
-// get first request
-request = list_entry(slave->slave_sdo_requests.next,
-ec_master_sdo_request_t, list);
-list_del_init(&request->list); // dequeue
-EC_INFO("Discarding SDO request,"
-" slave %u does not exist anymore.\n",
-slave->ring_position);
-request->req.state = EC_INT_REQUEST_FAILURE;
-wake_up(&slave->sdo_queue);
-}
-// FoE requests
-while (1) {
-ec_master_foe_request_t *request;
-if (list_empty(&slave->foe_requests))
-break;
-// get first request
-request = list_entry(slave->foe_requests.next,
-ec_master_foe_request_t, list);
-list_del_init(&request->list); // dequeue
-EC_INFO("Discarding FoE request,"
-" slave %u does not exist anymore.\n",
-slave->ring_position);
-request->req.state = EC_INT_REQUEST_FAILURE;
-wake_up(&slave->foe_queue);
-}
-// SoE requests
-while (1) {
-ec_master_soe_request_t *request;
-if (list_empty(&slave->soe_requests))
-break;
-// get first request
-request = list_entry(slave->soe_requests.next,
-ec_master_soe_request_t, list);
-list_del_init(&request->list); // dequeue
-EC_INFO("Discarding SoE request,"
-" slave %u does not exist anymore.\n",
-slave->ring_position);
-request->req.state = EC_INT_REQUEST_FAILURE;
-wake_up(&slave->soe_queue);
-}
 ec_slave_clear(slave);
 }
 if (master->slaves) {
 kfree(master->slaves);
 ec_master_t *master, /**< EtherCAT master */
 int (*thread_func)(void *), /**< thread function to start */
 const char *name /**< Thread name. */
 )
 {
-EC_INFO("Starting %s thread.\n", name);
+EC_MASTER_INFO(master, "Starting %s thread.\n", name);
 master->thread = kthread_run(thread_func, master, name);
 if (IS_ERR(master->thread)) {
 int err = (int) PTR_ERR(master->thread);
-EC_ERR("Failed to start master thread (error %i)!\n", err);
+EC_MASTER_ERR(master, "Failed to start master thread (error %i)!\n",
+err);
 master->thread = NULL;
 return err;
 }
 return 0;
 )
 {
 unsigned long sleep_jiffies;
 if (!master->thread) {
-EC_WARN("ec_master_thread_stop(): Already finished!\n");
+EC_MASTER_WARN(master, "%s(): Already finished!\n", __func__);
 return;
 }
-if (master->debug_level)
+EC_MASTER_DBG(master, 1, "Stopping master thread.\n");
-EC_DBG("Stopping master thread.\n");
 kthread_stop(master->thread);
 master->thread = NULL;
-EC_INFO("Master thread exited.\n");
+EC_MASTER_INFO(master, "Master thread exited.\n");
 if (master->fsm_datagram.state != EC_DATAGRAM_SENT)
 return;
 // wait for FSM datagram
 ec_master_t *master /**< EtherCAT master */
 )
 {
 int ret;
-if (master->debug_level)
+EC_MASTER_DBG(master, 1, "ORPHANED -> IDLE.\n");
-EC_DBG("ORPHANED -> IDLE.\n");
 master->send_cb = ec_master_internal_send_cb;
 master->receive_cb = ec_master_internal_receive_cb;
 master->cb_data = master;
 /** Transition function from IDLE to ORPHANED phase.
 */
 void ec_master_leave_idle_phase(ec_master_t *master /**< EtherCAT master */)
 {
-if (master->debug_level)
+EC_MASTER_DBG(master, 1, "IDLE -> ORPHANED.\n");
-EC_DBG("IDLE -> ORPHANED.\n");
 master->phase = EC_ORPHANED;
 #ifdef EC_EOE
 ec_master_eoe_stop(master);
 ec_slave_t *slave;
 #ifdef EC_EOE
 ec_eoe_t *eoe;
 #endif
-if (master->debug_level)
+EC_MASTER_DBG(master, 1, "IDLE -> OPERATION.\n");
-EC_DBG("IDLE -> OPERATION.\n");
 down(&master->config_sem);
 master->allow_config = 0; // temporarily disable slave configuration
 if (master->config_busy) {
 up(&master->config_sem);
 // wait for slave configuration to complete
 ret = wait_event_interruptible(master->config_queue,
 !master->config_busy);
 if (ret) {
-EC_INFO("Finishing slave configuration interrupted by signal.\n");
+EC_MASTER_INFO(master, "Finishing slave configuration"
+" interrupted by signal.\n");
 goto out_allow;
 }
-if (master->debug_level)
+EC_MASTER_DBG(master, 1, "Waiting for pending slave"
-EC_DBG("Waiting for pending slave configuration returned.\n");
+" configuration returned.\n");
 } else {
 up(&master->config_sem);
 }
 down(&master->scan_sem);
 up(&master->scan_sem);
 // wait for slave scan to complete
 ret = wait_event_interruptible(master->scan_queue, !master->scan_busy);
 if (ret) {
-EC_INFO("Waiting for slave scan interrupted by signal.\n");
+EC_MASTER_INFO(master, "Waiting for slave scan"
+" interrupted by signal.\n");
 goto out_allow;
 }
-if (master->debug_level)
+EC_MASTER_DBG(master, 1, "Waiting for pending"
-EC_DBG("Waiting for pending slave scan returned.\n");
+" slave scan returned.\n");
 }
 // set states for all slaves
 for (slave = master->slaves;
 slave < master->slaves + master->slave_count;
 )
 {
 if (master->active)
 ecrt_master_deactivate(master);
-if (master->debug_level)
+EC_MASTER_DBG(master, 1, "OPERATION -> IDLE.\n");
-EC_DBG("OPERATION -> IDLE.\n");
 master->phase = EC_IDLE;
 }
 queue) {
 queue_size += datagram->data_size;
 if (queue_size <= master->max_queue_size) {
 list_del_init(&datagram->queue);
 #if DEBUG_INJECT
-if (master->debug_level) {
+EC_MASTER_DBG(master, 0, "Injecting external datagram %08x"
-EC_DBG("Injecting external datagram %08x size=%u,"
+" size=%u, queue_size=%u\n", (unsigned int) datagram,
-" queue_size=%u\n", (unsigned int) datagram,
+datagram->data_size, queue_size);
-datagram->data_size, queue_size);
-}
 #endif
 #ifdef EC_HAVE_CYCLES
 datagram->cycles_sent = 0;
 #endif
 datagram->jiffies_sent = 0;
 }
 else {
 if (datagram->data_size > master->max_queue_size) {
 list_del_init(&datagram->queue);
 datagram->state = EC_DATAGRAM_ERROR;
-EC_ERR("External datagram %p is too large,"
+EC_MASTER_ERR(master, "External datagram %p is too large,"
 " size=%u, max_queue_size=%u\n",
 datagram, datagram->data_size,
 master->max_queue_size);
 } else {
 #ifdef EC_HAVE_CYCLES
 / cpu_khz;
 #else
 time_us = (unsigned int)
 ((jiffies - datagram->jiffies_sent) * 1000000 / HZ);
 #endif
-EC_ERR("Timeout %u us: injecting external datagram %p"
+EC_MASTER_ERR(master, "Timeout %u us: Injecting"
-" size=%u, max_queue_size=%u\n",
+" external datagram %p size=%u,"
-time_us, datagram,
+" max_queue_size=%u\n", time_us, datagram,
 datagram->data_size, master->max_queue_size);
 }
 #if DEBUG_INJECT
-else if (master->debug_level) {
+else {
-EC_DBG("Deferred injecting of external datagram %p"
+EC_MASTER_DBG(master, 0, "Deferred injecting"
+" of external datagram %p"
 " size=%u, queue_size=%u\n",
 datagram, datagram->data_size, queue_size);
 }
 #endif
 }
 return;
 }
 }
 #if DEBUG_INJECT
-if (master->debug_level) {
+EC_MASTER_DBG(master, 0, "Requesting external datagram %p size=%u\n",
-EC_DBG("Requesting external datagram %p size=%u\n",
+datagram, datagram->data_size);
-datagram, datagram->data_size);
-}
 #endif
 list_add_tail(&datagram->queue, &master->external_datagram_queue);
 datagram->state = EC_DATAGRAM_QUEUED;
 #ifdef EC_HAVE_CYCLES
 return;
 // check, if the datagram is already queued
 list_for_each_entry(queued_datagram, &master->datagram_queue, queue) {
 if (queued_datagram == datagram) {
 datagram->skip_count++;
-if (master->debug_level)
+EC_MASTER_DBG(master, 1, "skipping datagram %p.\n", datagram);
-EC_DBG("skipping datagram %p.\n", datagram);
 datagram->state = EC_DATAGRAM_QUEUED;
 return;
 }
 }
 cycles_start = get_cycles();
 #endif
 frame_count = 0;
 INIT_LIST_HEAD(&sent_datagrams);
-if (unlikely(master->debug_level > 1))
+EC_MASTER_DBG(master, 2, "ec_master_send_datagrams\n");
-EC_DBG("ec_master_send_datagrams\n");
 do {
 // fetch pointer to transmit socket buffer
 frame_data = ec_device_tx_data(&master->main_device);
 cur_data = frame_data + EC_FRAME_HEADER_SIZE;
 }
 list_add_tail(&datagram->sent, &sent_datagrams);
 datagram->index = master->datagram_index++;
-if (unlikely(master->debug_level > 1))
+EC_MASTER_DBG(master, 2, "adding datagram 0x%02X\n",
-EC_DBG("adding datagram 0x%02X\n", datagram->index);
+datagram->index);
 // set "datagram following" flag in previous frame
 if (follows_word)
 EC_WRITE_U16(follows_word, EC_READ_U16(follows_word) | 0x8000);
 EC_WRITE_U16(cur_data, 0x0000); // reset working counter
 cur_data += EC_DATAGRAM_FOOTER_SIZE;
 }
 if (list_empty(&sent_datagrams)) {
-if (unlikely(master->debug_level > 1))
+EC_MASTER_DBG(master, 2, "nothing to send.\n");
-EC_DBG("nothing to send.\n");
 break;
 }
 // EtherCAT frame header
 EC_WRITE_U16(frame_data, ((cur_data - frame_data
 // pad frame
 while (cur_data - frame_data < ETH_ZLEN - ETH_HLEN)
 EC_WRITE_U8(cur_data++, 0x00);
-if (unlikely(master->debug_level > 1))
+EC_MASTER_DBG(master, 2, "frame size: %zu\n", cur_data - frame_data);
-EC_DBG("frame size: %zu\n", cur_data - frame_data);
 // send frame
 ec_device_send(&master->main_device, cur_data - frame_data);
 #ifdef EC_HAVE_CYCLES
 cycles_sent = get_cycles();
 while (more_datagrams_waiting);
 #ifdef EC_HAVE_CYCLES
 if (unlikely(master->debug_level > 1)) {
 cycles_end = get_cycles();
-EC_DBG("ec_master_send_datagrams sent %u frames in %uus.\n",
+EC_MASTER_DBG(master, 0, "ec_master_send_datagrams"
-frame_count,
+" sent %u frames in %uus.\n", frame_count,
 (unsigned int) (cycles_end - cycles_start) * 1000 / cpu_khz);
 }
 #endif
 }
 const uint8_t *cur_data;
 ec_datagram_t *datagram;
 if (unlikely(size < EC_FRAME_HEADER_SIZE)) {
 if (master->debug_level) {
-EC_DBG("Corrupted frame received (size %zu < %u byte):\n",
+EC_MASTER_DBG(master, 0, "Corrupted frame received"
+" (size %zu < %u byte):\n",
 size, EC_FRAME_HEADER_SIZE);
 ec_print_data(frame_data, size);
 }
 master->stats.corrupted++;
 ec_master_output_stats(master);
 frame_size = EC_READ_U16(cur_data) & 0x07FF;
 cur_data += EC_FRAME_HEADER_SIZE;
 if (unlikely(frame_size > size)) {
 if (master->debug_level) {
-EC_DBG("Corrupted frame received (invalid frame size %zu for "
+EC_MASTER_DBG(master, 0, "Corrupted frame received"
+" (invalid frame size %zu for "
 "received size %zu):\n", frame_size, size);
 ec_print_data(frame_data, size);
 }
 master->stats.corrupted++;
 ec_master_output_stats(master);
 cur_data += EC_DATAGRAM_HEADER_SIZE;
 if (unlikely(cur_data - frame_data
 + data_size + EC_DATAGRAM_FOOTER_SIZE > size)) {
 if (master->debug_level) {
-EC_DBG("Corrupted frame received (invalid data size %zu):\n",
+EC_MASTER_DBG(master, 0, "Corrupted frame received"
-data_size);
+" (invalid data size %zu):\n", data_size);
 ec_print_data(frame_data, size);
 }
 master->stats.corrupted++;
 ec_master_output_stats(master);
 return;
 if (!matched) {
 master->stats.unmatched++;
 ec_master_output_stats(master);
 if (unlikely(master->debug_level > 0)) {
-EC_DBG("UNMATCHED datagram:\n");
+EC_MASTER_DBG(master, 0, "UNMATCHED datagram:\n");
 ec_print_data(cur_data - EC_DATAGRAM_HEADER_SIZE,
 EC_DATAGRAM_HEADER_SIZE + data_size
 + EC_DATAGRAM_FOOTER_SIZE);
 #ifdef EC_DEBUG_RING
 ec_device_debug_ring_print(&master->main_device);
 {
 if (unlikely(jiffies - master->stats.output_jiffies >= HZ)) {
 master->stats.output_jiffies = jiffies;
 if (master->stats.timeouts) {
-EC_WARN("%u datagram%s TIMED OUT!\n", master->stats.timeouts,
+EC_MASTER_WARN(master, "%u datagram%s TIMED OUT!\n",
+master->stats.timeouts,
 master->stats.timeouts == 1 ? "" : "s");
 master->stats.timeouts = 0;
 }
 if (master->stats.corrupted) {
-EC_WARN("%u frame%s CORRUPTED!\n", master->stats.corrupted,
+EC_MASTER_WARN(master, "%u frame%s CORRUPTED!\n",
+master->stats.corrupted,
 master->stats.corrupted == 1 ? "" : "s");
 master->stats.corrupted = 0;
 }
 if (master->stats.unmatched) {
-EC_WARN("%u datagram%s UNMATCHED!\n", master->stats.unmatched,
+EC_MASTER_WARN(master, "%u datagram%s UNMATCHED!\n",
+master->stats.unmatched,
 master->stats.unmatched == 1 ? "" : "s");
 master->stats.unmatched = 0;
 }
 }
 }
 size_t sent_bytes;
 // send interval in IDLE phase
 ec_master_set_send_interval(master, 1000000 / HZ);
-if (master->debug_level)
+EC_MASTER_DBG(master, 1, "Idle thread running with send interval = %d us,"
-EC_DBG("Idle thread running with send interval = %d us,"
+" max data size=%d\n", master->send_interval,
-" max data size=%d\n", master->send_interval,
+master->max_queue_size);
-master->max_queue_size);
 while (!kthread_should_stop()) {
 ec_datagram_output_stats(&master->fsm_datagram);
 // receive
 schedule();
 #endif
 }
 }
-if (master->debug_level)
+EC_MASTER_DBG(master, 1, "Master IDLE thread exiting...\n");
-EC_DBG("Master IDLE thread exiting...\n");
 return 0;
 }
 /*****************************************************************************/
 {
 ec_master_t *master = (ec_master_t *) priv_data;
 ec_slave_t *slave = NULL;
 int fsm_exec;
-if (master->debug_level)
+EC_MASTER_DBG(master, 1, "Operation thread running"
-EC_DBG("Operation thread running with fsm interval = %d us,"
+" with fsm interval = %d us, max data size=%d\n",
-" max data size=%d\n",
+master->send_interval, master->max_queue_size);
-master->send_interval,
-master->max_queue_size);
 while (!kthread_should_stop()) {
 ec_datagram_output_stats(&master->fsm_datagram);
 if (master->injection_seq_rt == master->injection_seq_fsm) {
 schedule();
 }
 #endif
 }
-if (master->debug_level)
+EC_MASTER_DBG(master, 1, "Master OP thread exiting...\n");
-EC_DBG("Master OP thread exiting...\n");
 return 0;
 }
 /*****************************************************************************/
 void ec_master_eoe_start(ec_master_t *master /**< EtherCAT master */)
 {
 struct sched_param param = { .sched_priority = 0 };
 if (master->eoe_thread) {
-EC_WARN("EoE already running!\n");
+EC_MASTER_WARN(master, "EoE already running!\n");
 return;
 }
 if (list_empty(&master->eoe_handlers))
 return;
 if (!master->send_cb || !master->receive_cb) {
-EC_WARN("No EoE processing because of missing callbacks!\n");
+EC_MASTER_WARN(master, "No EoE processing"
+" because of missing callbacks!\n");
 return;
 }
-EC_INFO("Starting EoE thread.\n");
+EC_MASTER_INFO(master, "Starting EoE thread.\n");
 master->eoe_thread = kthread_run(ec_master_eoe_thread, master,
 "EtherCAT-EoE");
 if (IS_ERR(master->eoe_thread)) {
 int err = (int) PTR_ERR(master->eoe_thread);
-EC_ERR("Failed to start EoE thread (error %i)!\n", err);
+EC_MASTER_ERR(master, "Failed to start EoE thread (error %i)!\n",
+err);
 master->eoe_thread = NULL;
 return;
 }
 sched_setscheduler(master->eoe_thread, SCHED_NORMAL, &param);
 /** Stops the Ethernet over EtherCAT processing.
 */
 void ec_master_eoe_stop(ec_master_t *master /**< EtherCAT master */)
 {
 if (master->eoe_thread) {
-EC_INFO("Stopping EoE thread.\n");
+EC_MASTER_INFO(master, "Stopping EoE thread.\n");
 kthread_stop(master->eoe_thread);
 master->eoe_thread = NULL;
-EC_INFO("EoE thread exited.\n");
+EC_MASTER_INFO(master, "EoE thread exited.\n");
 }
 }
 /*****************************************************************************/
 {
 ec_master_t *master = (ec_master_t *) priv_data;
 ec_eoe_t *eoe;
 unsigned int none_open, sth_to_send, all_idle;
-if (master->debug_level)
+EC_MASTER_DBG(master, 1, "EoE thread running.\n");
-EC_DBG("EoE thread running.\n");
 while (!kthread_should_stop()) {
 none_open = 1;
 all_idle = 1;
 } else {
 schedule();
 }
 }
-if (master->debug_level)
+EC_MASTER_DBG(master, 1, "EoE thread exiting...\n");
-EC_DBG("EoE thread exiting...\n");
 return 0;
 }
 #endif
 /*****************************************************************************/
 ec_master_t *master, /**< EtherCAT master. */
 unsigned int level /**< Debug level. May be 0, 1 or 2. */
 )
 {
 if (level > 2) {
-EC_ERR("Invalid debug level %u!\n", level);
+EC_MASTER_ERR(master, "Invalid debug level %u!\n", level);
 return -EINVAL;
 }
 if (level != master->debug_level) {
 master->debug_level = level;
-EC_INFO("Master debug level set to %u.\n", master->debug_level);
+EC_MASTER_INFO(master, "Master debug level set to %u.\n",
+master->debug_level);
 }
 return 0;
 }
 if (master->slave_count == 0)
 return;
 if (ec_master_calc_topology_rec(master, NULL, &slave_position))
-EC_ERR("Failed to calculate bus topology.\n");
+EC_MASTER_ERR(master, "Failed to calculate bus topology.\n");
 }
 /*****************************************************************************/
 /** Calculates the bus transmission delays.
 )
 {
 ec_domain_t *domain, *last_domain;
 unsigned int index;
-if (master->debug_level)
+EC_MASTER_DBG(master, 1, "ecrt_master_create_domain(master = 0x%p)\n",
-EC_DBG("ecrt_master_create_domain(master = 0x%p)\n", master);
+master);
 if (!(domain = (ec_domain_t *) kmalloc(sizeof(ec_domain_t), GFP_KERNEL))) {
-EC_ERR("Error allocating domain memory!\n");
+EC_MASTER_ERR(master, "Error allocating domain memory!\n");
 return ERR_PTR(-ENOMEM);
 }
 down(&master->master_sem);
 ec_domain_init(domain, master, index);
 list_add_tail(&domain->list, &master->domains);
 up(&master->master_sem);
-if (master->debug_level)
+EC_MASTER_DBG(master, 1, "Created domain %u.\n", domain->index);
-EC_DBG("Created domain %u.\n", domain->index);
 return domain;
 }
 /*****************************************************************************/
 int ret;
 #ifdef EC_EOE
 int eoe_was_running;
 #endif
-if (master->debug_level)
+EC_MASTER_DBG(master, 1, "ecrt_master_activate(master = 0x%p)\n", master);
-EC_DBG("ecrt_master_activate(master = 0x%p)\n", master);
 if (master->active) {
-EC_WARN("%s: Master already active!\n", __func__);
+EC_MASTER_WARN(master, "%s: Master already active!\n", __func__);
 return 0;
 }
 down(&master->master_sem);
 domain_offset = 0;
 list_for_each_entry(domain, &master->domains, list) {
 ret = ec_domain_finish(domain, domain_offset);
 if (ret < 0) {
 up(&master->master_sem);
-EC_ERR("Failed to finish domain 0x%p!\n", domain);
+EC_MASTER_ERR(master, "Failed to finish domain 0x%p!\n", domain);
 return ret;
 }
 domain_offset += domain->data_size;
 }
 #ifdef EC_EOE
 eoe_was_running = master->eoe_thread != NULL;
 ec_master_eoe_stop(master);
 #endif
-if (master->debug_level)
+EC_MASTER_DBG(master, 1, "FSM datagram is %p.\n", &master->fsm_datagram);
-EC_DBG("FSM datagram is %p.\n", &master->fsm_datagram);
 master->injection_seq_fsm = 0;
 master->injection_seq_rt = 0;
 master->send_cb = master->app_send_cb;
 }
 #endif
 ret = ec_master_thread_start(master, ec_master_operation_thread,
 "EtherCAT-OP");
 if (ret < 0) {
-EC_ERR("Failed to start master thread!\n");
+EC_MASTER_ERR(master, "Failed to start master thread!\n");
 return ret;
 }
 master->allow_config = 1; // request the current configuration
 master->allow_scan = 1; // allow re-scanning on topology change
 #ifdef EC_EOE
 ec_eoe_t *eoe;
 int eoe_was_running;
 #endif
-if (master->debug_level)
+EC_MASTER_DBG(master, 1, "ecrt_master_deactivate(master = 0x%x)\n",
-EC_DBG("ecrt_master_deactivate(master = 0x%x)\n", (u32) master);
+(u32) master);
 if (!master->active) {
-EC_WARN("%s: Master not active.\n", __func__);
+EC_MASTER_WARN(master, "%s: Master not active.\n", __func__);
 return;
 }
 ec_master_thread_stop(master);
 #ifdef EC_EOE
 ec_master_eoe_start(master);
 }
 #endif
 if (ec_master_thread_start(master, ec_master_idle_thread,
 "EtherCAT-IDLE"))
-EC_WARN("Failed to restart master thread!\n");
+EC_MASTER_WARN(master, "Failed to restart master thread!\n");
 master->allow_scan = 1;
 master->allow_config = 1;
 master->active = 0;
 }
 datagram->cycles_sent) * 1000 / cpu_khz;
 #else
 time_us = (unsigned int) ((master->main_device.jiffies_poll -
 datagram->jiffies_sent) * 1000000 / HZ);
 #endif
-EC_DBG("TIMED OUT datagram %p, index %02X waited %u us.\n",
+EC_MASTER_DBG(master, 0, "TIMED OUT datagram %p,"
+" index %02X waited %u us.\n",
 datagram, datagram->index, time_us);
 }
 }
 }
 }
 {
 ec_slave_config_t *sc;
 unsigned int found = 0;
-if (master->debug_level)
+EC_MASTER_DBG(master, 1, "ecrt_master_slave_config(master = 0x%p,"
-EC_DBG("ecrt_master_slave_config(master = 0x%p, alias = %u, "
+" alias = %u, position = %u, vendor_id = 0x%08x,"
-"position = %u, vendor_id = 0x%08x, product_code = 0x%08x)\n",
+" product_code = 0x%08x)\n",
 master, alias, position, vendor_id, product_code);
 list_for_each_entry(sc, &master->configs, list) {
 if (sc->alias == alias && sc->position == position) {
 found = 1;
 break;
 }
 }
 if (found) { // config with same alias/position already existing
 if (sc->vendor_id != vendor_id || sc->product_code != product_code) {
-EC_ERR("Slave type mismatch. Slave was configured as"
+EC_MASTER_ERR(master, "Slave type mismatch. Slave was"
-" 0x%08X/0x%08X before. Now configuring with"
+" configured as 0x%08X/0x%08X before. Now configuring"
-" 0x%08X/0x%08X.\n", sc->vendor_id, sc->product_code,
+" with 0x%08X/0x%08X.\n", sc->vendor_id, sc->product_code,
 vendor_id, product_code);
 return ERR_PTR(-ENOENT);
 }
 } else {
-if (master->debug_level)
+EC_MASTER_DBG(master, 1, "Creating slave configuration for %u:%u,"
-EC_DBG("Creating slave configuration for %u:%u, 0x%08X/0x%08X.\n",
+" 0x%08X/0x%08X.\n",
 alias, position, vendor_id, product_code);
 if (!(sc = (ec_slave_config_t *) kmalloc(sizeof(ec_slave_config_t),
 GFP_KERNEL))) {
-EC_ERR("Failed to allocate memory for slave configuration.\n");
+EC_MASTER_ERR(master, "Failed to allocate memory"
+" for slave configuration.\n");
 return ERR_PTR(-ENOMEM);
 }
 ec_slave_config_init(sc, master,
 alias, position, vendor_id, product_code);
 /*****************************************************************************/
 int ecrt_master(ec_master_t *master, ec_master_info_t *master_info)
 {
-if (master->debug_level)
+EC_MASTER_DBG(master, 1, "ecrt_master(master = 0x%p,"
-EC_DBG("ecrt_master(master = 0x%p, master_info = 0x%p)\n",
+" master_info = 0x%p)\n", master, master_info);
-master, master_info);
 master_info->slave_count = master->slave_count;
 master_info->link_up = master->main_device.link_state;
 master_info->scan_busy = master->scan_busy;
 master_info->app_time = master->app_time;
 /*****************************************************************************/
 void ecrt_master_callbacks(ec_master_t *master,
 void (*send_cb)(void *), void (*receive_cb)(void *), void *cb_data)
 {
-if (master->debug_level)
+EC_MASTER_DBG(master, 1, "ecrt_master_callbacks(master = 0x%p,"
-EC_DBG("ecrt_master_callbacks(master = 0x%p, send_cb = 0x%p, "
+" send_cb = 0x%p, receive_cb = 0x%p, cb_data = 0x%p)\n",
-" receive_cb = 0x%p, cb_data = 0x%p)\n", master,
+master, send_cb, receive_cb, cb_data);
-send_cb, receive_cb, cb_data);
 master->app_send_cb = send_cb;
 master->app_receive_cb = receive_cb;
 master->app_cb_data = cb_data;
 }

changeset 1921	d9cf40facbc4
parent 1914	da7adbde2625
child 1925	29161abef052