etherlabmaster: comparison master/master.c

equal deleted inserted replaced

-:74853e018898
+:ed15eef57d5c
 const uint8_t *backup_mac, /**< MAC address of backup device */
 dev_t device_number, /**< Character device number. */
 struct class *class /**< Device class. */
 )
 {
+int ret;
 master->index = index;
 master->reserved = 0;
 init_MUTEX(&master->master_sem);
 INIT_LIST_HEAD(&master->phy_requests);
 init_waitqueue_head(&master->phy_queue);
 // init devices
-if (ec_device_init(&master->main_device, master))
+ret = ec_device_init(&master->main_device, master);
+if (ret < 0)
 goto out_return;
-if (ec_device_init(&master->backup_device, master))
+ret = ec_device_init(&master->backup_device, master);
+if (ret < 0)
 goto out_clear_main;
 // init state machine datagram
 ec_datagram_init(&master->fsm_datagram);
 snprintf(master->fsm_datagram.name, EC_DATAGRAM_NAME_SIZE, "master-fsm");
-if (ec_datagram_prealloc(&master->fsm_datagram, EC_MAX_DATA_SIZE)) {
+ret = ec_datagram_prealloc(&master->fsm_datagram, EC_MAX_DATA_SIZE);
+if (ret < 0) {
 EC_ERR("Failed to allocate FSM datagram.\n");
 goto out_clear_backup;
 }
 // create state machine object
 ec_fsm_master_init(&master->fsm, master, &master->fsm_datagram);
 // init character device
-if (ec_cdev_init(&master->cdev, master, device_number))
+ret = ec_cdev_init(&master->cdev, master, device_number);
+if (ret)
 goto out_clear_fsm;
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26)
 master->class_device = device_create(class, NULL,
 MKDEV(MAJOR(device_number), master->index),
 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");
+ret = PTR_ERR(master->class_device);
 goto out_clear_cdev;
 }
 return 0;
 out_clear_backup:
 ec_device_clear(&master->backup_device);
 out_clear_main:
 ec_device_clear(&master->main_device);
 out_return:
-return -1;
+return ret;
 }
 /*****************************************************************************/
 /** Destructor.
 }
 /*****************************************************************************/
 /** Starts the master thread.
+*
+* \retval  0 Success.
+* \retval <0 Error code.
 */
 int ec_master_thread_start(
 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);
 master->thread = kthread_run(thread_func, master, name);
 if (IS_ERR(master->thread)) {
-EC_ERR("Failed to start master thread (error %i)!\n",
+int err = (int) PTR_ERR(master->thread);
-(int) PTR_ERR(master->thread));
+EC_ERR("Failed to start master thread (error %i)!\n", err);
 master->thread = NULL;
-return -1;
+return err;
 }
 return 0;
 }
 */
 int ec_master_enter_idle_phase(
 ec_master_t *master /**< EtherCAT master */
 )
 {
+int ret;
 if (master->debug_level)
 EC_DBG("ORPHANED -> IDLE.\n");
 master->request_cb = ec_master_request_cb;
 master->release_cb = ec_master_release_cb;
 master->cb_data = master;
 master->phase = EC_IDLE;
-if (ec_master_thread_start(master, ec_master_idle_thread,
+ret = ec_master_thread_start(master, ec_master_idle_thread,
-"EtherCAT-IDLE")) {
+"EtherCAT-IDLE");
+if (ret)
 master->phase = EC_ORPHANED;
-return -1;
-}
+return ret;
-return 0;
 }
 /*****************************************************************************/
 /** Transition function from IDLE to ORPHANED phase.
 /** Transition function from IDLE to OPERATION phase.
 */
 int ec_master_enter_operation_phase(ec_master_t *master /**< EtherCAT master */)
 {
+int ret = 0;
 ec_slave_t *slave;
 #ifdef EC_EOE
 ec_eoe_t *eoe;
 #endif
 master->allow_config = 0; // temporarily disable slave configuration
 if (master->config_busy) {
 up(&master->config_sem);
 // wait for slave configuration to complete
-if (wait_event_interruptible(master->config_queue,
+ret = wait_event_interruptible(master->config_queue,
-!master->config_busy)) {
+!master->config_busy);
+if (ret) {
 EC_INFO("Finishing slave configuration interrupted by signal.\n");
 goto out_allow;
 }
 if (master->debug_level)
 up(&master->scan_sem);
 } else {
 up(&master->scan_sem);
 // wait for slave scan to complete
-if (wait_event_interruptible(master->scan_queue, !master->scan_busy)) {
+ret = wait_event_interruptible(master->scan_queue, !master->scan_busy);
+if (ret) {
 EC_INFO("Waiting for slave scan interrupted by signal.\n");
 goto out_allow;
 }
 if (master->debug_level)
 master->phase = EC_OPERATION;
 master->ext_request_cb = NULL;
 master->ext_release_cb = NULL;
 master->ext_cb_data = NULL;
-return 0;
+return ret;
 out_allow:
 master->allow_scan = 1;
 master->allow_config = 1;
-return -1;
+return ret;
 }
 /*****************************************************************************/
 /** Transition function from OPERATION to IDLE phase.
 /*****************************************************************************/
 /** Set the debug level.
 *
-* \retval 0 Success.
+* \retval       0 Success.
-* \retval -1 Invalid debug level.
+* \retval -EINVAL Invalid debug level.
 */
 int ec_master_debug_level(
 ec_master_t *master, /**< EtherCAT master. */
 int level /**< Debug level. May be 0, 1 or 2. */
 )
 {
 if (level < 0 || level > 2) {
 EC_ERR("Invalid debug level %i!\n", level);
-return -1;
+return -EINVAL;
 }
 if (level != master->debug_level) {
 master->debug_level = level;
 EC_INFO("Master debug level set to %i.\n", master->debug_level);
 int ecrt_master_activate(ec_master_t *master)
 {
 uint32_t domain_offset;
 ec_domain_t *domain;
+int ret;
 if (master->debug_level)
 EC_DBG("ecrt_master_activate(master = 0x%x)\n", (u32) master);
 down(&master->master_sem);
 // finish all domains
 domain_offset = 0;
 list_for_each_entry(domain, &master->domains, list) {
-if (ec_domain_finish(domain, domain_offset)) {
+ret = ec_domain_finish(domain, domain_offset);
+if (ret < 0) {
 up(&master->master_sem);
 EC_ERR("Failed to finish domain 0x%08X!\n", (u32) domain);
-return -1;
+return ret;
 }
 domain_offset += domain->data_size;
 }
 up(&master->master_sem);
 master->injection_seq_rt = 0;
 master->request_cb = master->ext_request_cb;
 master->release_cb = master->ext_release_cb;
 master->cb_data = master->ext_cb_data;
-if (ec_master_thread_start(master, ec_master_operation_thread,
+ret = ec_master_thread_start(master, ec_master_operation_thread,
-"EtherCAT-OP")) {
+"EtherCAT-OP");
+if (ret < 0) {
 EC_ERR("Failed to start master thread!\n");
-return -1;
+return ret;
 }
 #ifdef EC_EOE
 ec_master_eoe_start(master);
 #endif

changeset 1313	ed15eef57d5c
parent 1312	74853e018898
child 1326	ef907b0b5125