ACPI: remove function tracing macros from drivers/acpi/*.c

a few invocations appeared due to the SBS and other patches.

Signed-off-by: Len Brown <[e-mail]>

drivers/acpi/cm_sbs.c

···
 
 struct proc_dir_entry *acpi_lock_ac_dir(void)
 {
-	ACPI_FUNCTION_TRACE("acpi_lock_ac_dir");
 
 	down(&cm_sbs_sem);
 	if (!acpi_ac_dir) {
···
 				  "Cannot create %s\n", ACPI_AC_CLASS));
 	}
 	up(&cm_sbs_sem);
-	return (acpi_ac_dir);
+	return acpi_ac_dir;
 }
 
 EXPORT_SYMBOL(acpi_lock_ac_dir);
 
 void acpi_unlock_ac_dir(struct proc_dir_entry *acpi_ac_dir_param)
 {
-	ACPI_FUNCTION_TRACE("acpi_unlock_ac_dir");
 
 	down(&cm_sbs_sem);
 	if (acpi_ac_dir_param) {
···
 
 struct proc_dir_entry *acpi_lock_battery_dir(void)
 {
-	ACPI_FUNCTION_TRACE("acpi_lock_battery_dir");
 
 	down(&cm_sbs_sem);
 	if (!acpi_battery_dir) {
···
 				  "Cannot create %s\n", ACPI_BATTERY_CLASS));
 	}
 	up(&cm_sbs_sem);
-	return (acpi_battery_dir);
+	return acpi_battery_dir;
 }
 
 EXPORT_SYMBOL(acpi_lock_battery_dir);
 
 void acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir_param)
 {
-	ACPI_FUNCTION_TRACE("acpi_unlock_battery_dir");
 
 	down(&cm_sbs_sem);
 	if (acpi_battery_dir_param) {
···
 		acpi_battery_dir = 0;
 	}
 	up(&cm_sbs_sem);
+	return;
 }
 
 EXPORT_SYMBOL(acpi_unlock_battery_dir);
 
 static int __init acpi_cm_sbs_init(void)
 {
-	ACPI_FUNCTION_TRACE("acpi_cm_sbs_init");
 
 	if (acpi_disabled)
-		return_VALUE(0);
+		return 0;
 
 	init_MUTEX(&cm_sbs_sem);
 
-	return_VALUE(0);
+	return 0;
 }
 
 subsys_initcall(acpi_cm_sbs_init);

drivers/acpi/i2c_ec.c

···
 	u8 val;
 	int err;
 
-	ACPI_FUNCTION_TRACE("acpi_ec_smb_read");
-
 	err = ec_read(smbus->base + address, &val);
 	if (!err) {
 		*data = val;
···
 static int acpi_ec_smb_write(struct acpi_ec_smbus *smbus, u8 address, u8 data)
 {
 	int err;
-
-	ACPI_FUNCTION_TRACE("acpi_ec_smb_write");
 
 	err = ec_write(smbus->base + address, data);
 	return (err);
···
 	struct acpi_ec_smbus *smbus = adap->algo_data;
 	unsigned char protocol, len = 0, pec, temp[2] = { 0, 0 };
 	int i;
-
-	ACPI_FUNCTION_TRACE("acpi_ec_smb_access");
 
 	if (read_write == I2C_SMBUS_READ) {
 		protocol = ACPI_EC_SMB_PRTCL_READ;
···
 
 static u32 acpi_ec_smb_func(struct i2c_adapter *adapter)
 {
-	ACPI_FUNCTION_TRACE("acpi_ec_smb_func");
 
 	return (I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
 		I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
···
 	struct acpi_ec_hc *ec_hc;
 	struct acpi_ec_smbus *smbus;
 
-	ACPI_FUNCTION_TRACE("acpi_ec_hc_add");
-
 	if (!device) {
-		return_VALUE(-EINVAL);
+		return -EINVAL;
 	}
 
 	ec_hc = kmalloc(sizeof(struct acpi_ec_hc), GFP_KERNEL);
 	if (!ec_hc) {
-		return_VALUE(-ENOMEM);
+		return -ENOMEM;
 	}
 	memset(ec_hc, 0, sizeof(struct acpi_ec_hc));
 
 	smbus = kmalloc(sizeof(struct acpi_ec_smbus), GFP_KERNEL);
 	if (!smbus) {
 		kfree(ec_hc);
-		return_VALUE(-ENOMEM);
+		return -ENOMEM;
 	}
 	memset(smbus, 0, sizeof(struct acpi_ec_smbus));
 
···
 		ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Error obtaining _EC\n"));
 		kfree(ec_hc->smbus);
 		kfree(smbus);
-		return_VALUE(-EIO);
+		return -EIO;
 	}
 
 	smbus->ec = acpi_driver_data(device->parent);
···
 				  "EC SMBus adapter: Failed to register adapter\n"));
 		kfree(smbus);
 		kfree(ec_hc);
-		return_VALUE(-EIO);
+		return -EIO;
 	}
 
 	ec_hc->smbus = smbus;
···
 	printk(KERN_INFO PREFIX "%s [%s]\n",
 	       acpi_device_name(device), acpi_device_bid(device));
 
-	return_VALUE(AE_OK);
+	return AE_OK;
 }
 
 static int acpi_ec_hc_remove(struct acpi_device *device, int type)
 {
 	struct acpi_ec_hc *ec_hc;
 
-	ACPI_FUNCTION_TRACE("acpi_ec_hc_remove");
-
 	if (!device) {
-		return_VALUE(-EINVAL);
+		return -EINVAL;
 	}
 	ec_hc = acpi_driver_data(device);
 
···
 	kfree(ec_hc->smbus);
 	kfree(ec_hc);
 
-	return_VALUE(AE_OK);
+	return AE_OK;
 }
 
 static int __init acpi_ec_hc_init(void)
 {
 	int result;
 
-	ACPI_FUNCTION_TRACE("acpi_ec_hc_init");
 	result = acpi_bus_register_driver(&acpi_ec_hc_driver);
 	if (result < 0) {
-		return_VALUE(-ENODEV);
+		return -ENODEV;
 	}
-	return_VALUE(0);
+	return 0;
 }
 
 static void __exit acpi_ec_hc_exit(void)
 {
-	ACPI_FUNCTION_TRACE("acpi_ec_hc_exit");
 	acpi_bus_unregister_driver(&acpi_ec_hc_driver);
 }
 
 struct acpi_ec_hc *acpi_get_ec_hc(struct acpi_device *device)
 {
-	ACPI_FUNCTION_TRACE("acpi_get_ec_hc");
 	return ((struct acpi_ec_hc *)acpi_driver_data(device->parent));
 }
 

drivers/acpi/numa.c

···
 {
 	int pxm, node = -1;
 
-	ACPI_FUNCTION_TRACE("acpi_get_node");
-
 	pxm = acpi_get_pxm(handle);
 	if (pxm >= 0)
 		node = acpi_map_pxm_to_node(pxm);
 
-	return_VALUE(node);
+	return node;
 }
 EXPORT_SYMBOL(acpi_get_node);

drivers/acpi/sbs.c

···
 	char *err_str;
 	int err_number;
 
-	ACPI_FUNCTION_TRACE("acpi_battery_smbus_err_handler");
-
 	data.word = 0;
 
 	result = smbus->adapter.algo->
···
 	int result = 0;
 	int i;
 
-	ACPI_FUNCTION_TRACE("acpi_sbs_smbus_read_word");
-
 	if (err_handler == NULL) {
 		err_handler = acpi_battery_smbus_err_handler;
 	}
···
 		}
 	}
 
-	return_VALUE(result);
+	return result;
 }
 
 static int
···
 	union i2c_smbus_data data;
 	int result = 0;
 	int i;
-
-	ACPI_FUNCTION_TRACE("acpi_sbs_smbus_read_str");
 
 	if (err_handler == NULL) {
 		err_handler = acpi_battery_smbus_err_handler;
···
 		}
 	}
 
-	return_VALUE(result);
+	return result;
 }
 
 static int
···
 	union i2c_smbus_data data;
 	int result = 0;
 	int i;
-
-	ACPI_FUNCTION_TRACE("acpi_sbs_smbus_write_word");
 
 	if (err_handler == NULL) {
 		err_handler = acpi_battery_smbus_err_handler;
···
 		}
 	}
 
-	return_VALUE(result);
+	return result;
 }
 
 /* --------------------------------------------------------------------------
···
 	char class_saved[20];
 	int result = 0;
 
-	ACPI_FUNCTION_TRACE("acpi_sbs_generate_event");
-
 	strcpy(bid_saved, acpi_device_bid(device));
 	strcpy(class_saved, acpi_device_class(device));
 
···
 	strcpy(acpi_device_bid(device), bid_saved);
 	strcpy(acpi_device_class(device), class_saved);
 
-	return_VALUE(result);
+	return result;
 }
 
 static int acpi_battery_get_present(struct acpi_battery *battery)
···
 	s16 state;
 	int result = 0;
 	int is_present = 0;
-
-	ACPI_FUNCTION_TRACE("acpi_battery_get_present");
 
 	result = acpi_sbs_smbus_read_word(battery->sbs->smbus,
 					  ACPI_SBSM_SMBUS_ADDR, 0x01,
···
 	}
 	battery->battery_present = is_present;
 
-	return_VALUE(result);
+	return result;
 }
 
 static int acpi_battery_is_present(struct acpi_battery *battery)
···
 	int result = 0;
 	s16 state;
 	int foo;
-
-	ACPI_FUNCTION_TRACE("acpi_battery_select");
 
 	if (battery->sbs->sbsm_present) {
 
···
 	}
 
       end:
-	return_VALUE(result);
+	return result;
 }
 
 static int acpi_sbsm_get_info(struct acpi_sbs *sbs)
···
 	struct acpi_ec_smbus *smbus = sbs->smbus;
 	int result = 0;
 	s16 battery_system_info;
-
-	ACPI_FUNCTION_TRACE("acpi_sbsm_get_info");
 
 	result = acpi_sbs_smbus_read_word(smbus, ACPI_SBSM_SMBUS_ADDR, 0x04,
 					  &battery_system_info, NULL);
···
 
       end:
 
-	return_VALUE(result);
+	return result;
 }
 
 static int acpi_battery_get_info(struct acpi_battery *battery)
···
 	int result = 0;
 	s16 battery_mode;
 	s16 specification_info;
-
-	ACPI_FUNCTION_TRACE("acpi_battery_get_info");
 
 	result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x03,
 					  &battery_mode,
···
 	}
 
       end:
-	return_VALUE(result);
+	return result;
 }
 
 static void acpi_update_delay(struct acpi_sbs *sbs)
 {
-	ACPI_FUNCTION_TRACE("acpi_update_delay");
 	if (sbs->zombie) {
 		return;
 	}
···
 {
 	struct acpi_ec_smbus *smbus = battery->sbs->smbus;
 	int result = 0;
-
-	ACPI_FUNCTION_TRACE("acpi_battery_get_state");
 
 	acpi_update_delay(battery->sbs);
 	result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x09,
···
 	acpi_update_delay(battery->sbs);
 
       end:
-	return_VALUE(result);
+	return result;
 }
 
 static int acpi_battery_get_alarm(struct acpi_battery *battery)
 {
 	struct acpi_ec_smbus *smbus = battery->sbs->smbus;
 	int result = 0;
-
-	ACPI_FUNCTION_TRACE("acpi_battery_get_alarm");
 
 	result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x01,
 					  &battery->alarm.remaining_capacity,
···
 
       end:
 
-	return_VALUE(result);
+	return result;
 }
 
 static int acpi_battery_set_alarm(struct acpi_battery *battery,
···
 	int result = 0;
 	s16 battery_mode;
 	int foo;
-
-	ACPI_FUNCTION_TRACE("acpi_battery_set_alarm");
 
 	result = acpi_battery_select(battery);
 	if (result) {
···
 
       end:
 
-	return_VALUE(result);
+	return result;
 }
 
 static int acpi_battery_set_mode(struct acpi_battery *battery)
 {
 	int result = 0;
 	s16 battery_mode;
-
-	ACPI_FUNCTION_TRACE("acpi_battery_set_mode");
 
 	if (capacity_mode == DEF_CAPACITY_UNIT) {
 		goto end;
···
 	}
 
       end:
-	return_VALUE(result);
+	return result;
 }
 
 static int acpi_battery_init(struct acpi_battery *battery)
 {
 	int result = 0;
-
-	ACPI_FUNCTION_TRACE("acpi_battery_init");
 
 	result = acpi_battery_select(battery);
 	if (result) {
···
 	}
 
       end:
-	return_VALUE(result);
+	return result;
 }
 
 static int acpi_ac_get_present(struct acpi_sbs *sbs)
···
 	struct acpi_ec_smbus *smbus = sbs->smbus;
 	int result = 0;
 	s16 charger_status;
-
-	ACPI_FUNCTION_TRACE("acpi_ac_get_present");
 
 	result = acpi_sbs_smbus_read_word(smbus, ACPI_SBC_SMBUS_ADDR, 0x13,
 					  &charger_status, NULL);
···
 
       end:
 
-	return_VALUE(result);
+	return result;
 }
 
 /* --------------------------------------------------------------------------
···
 {
 	struct proc_dir_entry *entry = NULL;
 
-	ACPI_FUNCTION_TRACE("acpi_sbs_generic_add_fs");
-
 	if (!*dir) {
 		*dir = proc_mkdir(dir_name, parent_dir);
 		if (!*dir) {
 			ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 					  "proc_mkdir() failed\n"));
-			return_VALUE(-ENODEV);
+			return -ENODEV;
 		}
 		(*dir)->owner = THIS_MODULE;
 	}
···
 		}
 	}
 
-	return_VALUE(0);
+	return 0;
 }
 
 static void
 acpi_sbs_generic_remove_fs(struct proc_dir_entry **dir,
 			   struct proc_dir_entry *parent_dir)
 {
-	ACPI_FUNCTION_TRACE("acpi_sbs_generic_remove_fs");
 
 	if (*dir) {
 		remove_proc_entry(ACPI_SBS_FILE_INFO, *dir);
···
 	int cscale;
 	int result = 0;
 
-	ACPI_FUNCTION_TRACE("acpi_battery_read_info");
-
 	if (battery->sbs->zombie) {
-		return_VALUE(-ENODEV);
+		return -ENODEV;
 	}
 
 	down(&sbs_sem);
···
 
 	up(&sbs_sem);
 
-	return_VALUE(result);
+	return result;
 }
 
 static int acpi_battery_info_open_fs(struct inode *inode, struct file *file)
···
 	int cscale;
 	int foo;
 
-	ACPI_FUNCTION_TRACE("acpi_battery_read_state");
-
 	if (battery->sbs->zombie) {
-		return_VALUE(-ENODEV);
+		return -ENODEV;
 	}
 
 	down(&sbs_sem);
···
 
 	up(&sbs_sem);
 
-	return_VALUE(result);
+	return result;
 }
 
 static int acpi_battery_state_open_fs(struct inode *inode, struct file *file)
···
 	int result = 0;
 	int cscale;
 
-	ACPI_FUNCTION_TRACE("acpi_battery_read_alarm");
-
 	if (battery->sbs->zombie) {
-		return_VALUE(-ENODEV);
+		return -ENODEV;
 	}
 
 	down(&sbs_sem);
···
 
 	up(&sbs_sem);
 
-	return_VALUE(result);
+	return result;
 }
 
 static ssize_t
···
 	char alarm_string[12] = { '\0' };
 	int result, old_alarm, new_alarm;
 
-	ACPI_FUNCTION_TRACE("acpi_battery_write_alarm");
-
 	if (battery->sbs->zombie) {
-		return_VALUE(-ENODEV);
+		return -ENODEV;
 	}
 
 	down(&sbs_sem);
···
 	up(&sbs_sem);
 
 	if (result) {
-		return_VALUE(result);
+		return result;
 	} else {
-		return_VALUE(count);
+		return count;
 	}
 }
 
···
 	struct acpi_sbs *sbs = (struct acpi_sbs *)seq->private;
 	int result;
 
-	ACPI_FUNCTION_TRACE("acpi_ac_read_state");
-
 	if (sbs->zombie) {
-		return_VALUE(-ENODEV);
+		return -ENODEV;
 	}
 
 	down(&sbs_sem);
···
 
 	up(&sbs_sem);
 
-	return_VALUE(0);
+	return 0;
 }
 
 static int acpi_ac_state_open_fs(struct inode *inode, struct file *file)
···
 	int result;
 	char dir_name[32];
 	struct acpi_battery *battery;
-
-	ACPI_FUNCTION_TRACE("acpi_battery_add");
 
 	battery = &sbs->battery[id];
 
···
 	battery->alive = 1;
 
       end:
-	return_VALUE(result);
+	return result;
 }
 
 static void acpi_battery_remove(struct acpi_sbs *sbs, int id)
 {
-	ACPI_FUNCTION_TRACE("acpi_battery_remove");
 
 	if (sbs->battery[id].battery_entry) {
 		acpi_sbs_generic_remove_fs(&(sbs->battery[id].battery_entry),
···
 static int acpi_ac_add(struct acpi_sbs *sbs)
 {
 	int result;
-
-	ACPI_FUNCTION_TRACE("acpi_ac_add");
 
 	result = acpi_ac_get_present(sbs);
 	if (result) {
···
 
       end:
 
-	return_VALUE(result);
+	return result;
 }
 
 static void acpi_ac_remove(struct acpi_sbs *sbs)
 {
-	ACPI_FUNCTION_TRACE("acpi_ac_remove");
 
 	if (sbs->ac_entry) {
 		acpi_sbs_generic_remove_fs(&sbs->ac_entry, acpi_ac_dir);
···
 
 static void acpi_sbs_update_queue_run(unsigned long data)
 {
-	ACPI_FUNCTION_TRACE("acpi_sbs_update_queue_run");
 	acpi_os_execute(OSL_GPE_HANDLER, acpi_sbs_update_queue, (void *)data);
 }
 
···
 	char dir_name[32];
 	int do_battery_init, do_ac_init;
 	s16 old_remaining_capacity;
-
-	ACPI_FUNCTION_TRACE("acpi_sbs_update_run");
 
 	if (sbs->zombie) {
 		goto end;
···
 	}
 
       end:
-	return_VALUE(result);
+	return result;
 }
 
 static void acpi_sbs_update_queue(void *data)
···
 	struct acpi_sbs *sbs = data;
 	unsigned long delay = -1;
 	int result;
-
-	ACPI_FUNCTION_TRACE("acpi_sbs_update_queue");
 
 	if (sbs->zombie) {
 		goto end;
···
 	int id, cnt;
 	acpi_status status = AE_OK;
 
-	ACPI_FUNCTION_TRACE("acpi_sbs_add");
-
 	sbs = kmalloc(sizeof(struct acpi_sbs), GFP_KERNEL);
 	if (!sbs) {
 		ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "kmalloc() failed\n"));
-		return_VALUE(-ENOMEM);
+		return -ENOMEM;
 	}
 	memset(sbs, 0, sizeof(struct acpi_sbs));
 
···
 		}
 	}
 
-	return_VALUE(result);
+	return result;
 }
 
 int acpi_sbs_remove(struct acpi_device *device, int type)
···
 	struct acpi_sbs *sbs = (struct acpi_sbs *)acpi_driver_data(device);
 	int id;
 
-	ACPI_FUNCTION_TRACE("acpi_sbs_remove");
-
 	if (!device || !sbs) {
-		return_VALUE(-EINVAL);
+		return -EINVAL;
 	}
 
 	sbs->zombie = 1;
···
 
 	kfree(sbs);
 
-	return_VALUE(0);
+	return 0;
 }
 
 static int __init acpi_sbs_init(void)
 {
 	int result = 0;
-
-	ACPI_FUNCTION_TRACE("acpi_sbs_init");
 
 	init_MUTEX(&sbs_sem);
 
···
 		ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "acpi_sbs_init: "
 				  "invalid capacity_mode = %d\n",
 				  capacity_mode));
-		return_VALUE(-EINVAL);
+		return -EINVAL;
 	}
 
 	acpi_ac_dir = acpi_lock_ac_dir();
 	if (!acpi_ac_dir) {
 		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 				  "acpi_lock_ac_dir() failed\n"));
-		return_VALUE(-ENODEV);
+		return -ENODEV;
 	}
 
 	acpi_battery_dir = acpi_lock_battery_dir();
 	if (!acpi_battery_dir) {
 		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 				  "acpi_lock_battery_dir() failed\n"));
-		return_VALUE(-ENODEV);
+		return -ENODEV;
 	}
 
 	result = acpi_bus_register_driver(&acpi_sbs_driver);
 	if (result < 0) {
 		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 				  "acpi_bus_register_driver() failed\n"));
-		return_VALUE(-ENODEV);
+		return -ENODEV;
 	}
 
-	return_VALUE(0);
+	return 0;
 }
 
 static void __exit acpi_sbs_exit(void)
 {
-	ACPI_FUNCTION_TRACE("acpi_sbs_exit");
 
 	acpi_bus_unregister_driver(&acpi_sbs_driver);
 
···
 	acpi_unlock_battery_dir(acpi_battery_dir);
 	acpi_battery_dir = NULL;
 
-	return_VOID;
+	return;
 }
 
 module_init(acpi_sbs_init);